@selesai/code 0.13.35 → 0.13.38

package/dist/extensions/ponytail/test/helpers.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createRequire } from "node:module";
@@ -21,11 +21,11 @@ describe("ponytail helpers", () => {
   });
 
   it("parsePonytailCommand falls back to DEFAULT_MODE for invalid defaults", () => {
-    expect(parsePonytailCommand("", "bogus")).toEqual({ type: "set-mode", mode: "full" });
+    expect(parsePonytailCommand("", "bogus")).toEqual({ type: "set-mode", mode: "lite" });
   });
 
   it("parsePonytailCommand parses modes, status, and default subcommand", () => {
-    expect(parsePonytailCommand("ultra", "full")).toEqual({ type: "set-mode", mode: "ultra" });
+    expect(parsePonytailCommand("lite", "full")).toEqual({ type: "set-mode", mode: "lite" });
     expect(parsePonytailCommand("status", "full")).toEqual({ type: "status" });
     expect(parsePonytailCommand("default lite", "full")).toEqual({ type: "set-default", mode: "lite" });
   });
@@ -42,44 +42,59 @@ describe("ponytail helpers", () => {
   it("resolveSessionMode prefers latest persisted session mode", () => {
     const entries = [
       { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } },
-      { type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } },
+      { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } },
     ];
 
-    expect(resolveSessionMode(entries, "full")).toBe("ultra");
+    expect(resolveSessionMode(entries, "full")).toBe("lite");
   });
 
   it("resolveSessionMode returns fallback when entries is not an array", () => {
-    expect(resolveSessionMode(null, "ultra")).toBe("ultra");
+    expect(resolveSessionMode(null, "lite")).toBe("lite");
     expect(resolveSessionMode(undefined, "lite")).toBe("lite");
     expect(resolveSessionMode({}, "full")).toBe("full");
-    expect(resolveSessionMode("not an array")).toBe("full"); // DEFAULT_MODE fallback
+    expect(resolveSessionMode("not an array")).toBe("lite"); // DEFAULT_MODE fallback
   });
 
   it("resolveSessionMode ignores non-ponytail entries and invalid modes", () => {
     const entries = [
-      { type: "custom", customType: "other", data: { mode: "ultra" } },
+      { type: "custom", customType: "other", data: { mode: "lite" } },
       { type: "custom", customType: "ponytail-mode", data: { mode: "bogus" } },
     ];
     expect(resolveSessionMode(entries, "lite")).toBe("lite");
   });
 
-  it("readDefaultMode and writeDefaultMode use XDG config path", () => {
+  it("readDefaultMode and writeDefaultMode use ponytailMode in agent settings.json", () => {
     const tempDir = mkdtempSync(join(tmpdir(), "ponytail-config-"));
-    const previousXdg = process.env.XDG_CONFIG_HOME;
+    const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
     const previousDefault = process.env.PONYTAIL_DEFAULT_MODE;
-    const configPath = join(tempDir, "ponytail", "config.json");
-    process.env.XDG_CONFIG_HOME = tempDir;
+    const settingsPath = join(tempDir, "settings.json");
+    process.env.SELESAI_CODING_AGENT_DIR = tempDir;
     delete process.env.PONYTAIL_DEFAULT_MODE;
 
     try {
-      expect(readDefaultMode()).toBe("full");
-      expect(writeDefaultMode("ultra")).toBe("ultra");
-      expect(readDefaultMode()).toBe("ultra");
-      expect(existsSync(configPath)).toBe(true);
-      expect(JSON.parse(readFileSync(configPath, "utf8"))).toEqual({ defaultMode: "ultra" });
+      expect(readDefaultMode()).toBe("lite");
+      expect(writeDefaultMode("lite")).toBe("lite");
+      expect(readDefaultMode()).toBe("lite");
+      expect(JSON.parse(readFileSync(settingsPath, "utf8"))).toEqual({ ponytailMode: "lite" });
+
+      // Other settings are preserved.
+      writeFileSync(settingsPath, JSON.stringify({ theme: "dark", ponytailMode: "lite" }));
+      writeDefaultMode("full");
+      expect(JSON.parse(readFileSync(settingsPath, "utf8"))).toEqual({ theme: "dark", ponytailMode: "full" });
+
+      // Removed/unknown modes are ignored, not honored.
+      writeFileSync(settingsPath, JSON.stringify({ ponytailMode: "ultra" }));
+      expect(readDefaultMode()).toBe("lite");
+      expect(writeDefaultMode("ultra")).toBeNull();
+
+      // An unparseable settings.json is never overwritten.
+      writeFileSync(settingsPath, "{ not json");
+      expect(() => writeDefaultMode("lite")).toThrow();
+      expect(readFileSync(settingsPath, "utf8")).toBe("{ not json");
+      expect(readDefaultMode()).toBe("lite");
     } finally {
-      if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
-      else process.env.XDG_CONFIG_HOME = previousXdg;
+      if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+      else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
       if (previousDefault === undefined) delete process.env.PONYTAIL_DEFAULT_MODE;
       else process.env.PONYTAIL_DEFAULT_MODE = previousDefault;
       rmSync(tempDir, { recursive: true, force: true });
@@ -97,11 +112,11 @@ describe("ponytail helpers", () => {
     }
   });
 
-  it("readDefaultMode falls back to full when env is invalid", () => {
+  it("readDefaultMode falls back to lite when env is invalid", () => {
     const previous = process.env.PONYTAIL_DEFAULT_MODE;
     process.env.PONYTAIL_DEFAULT_MODE = "bogus";
     try {
-      expect(readDefaultMode()).toBe("full");
+      expect(readDefaultMode()).toBe("lite");
     } finally {
       if (previous === undefined) delete process.env.PONYTAIL_DEFAULT_MODE;
       else process.env.PONYTAIL_DEFAULT_MODE = previous;
@@ -113,45 +128,33 @@ describe("ponytail helpers", () => {
   });
 
   it("filterSkillBodyForMode keeps only requested intensity examples and rows", () => {
-    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 body = `---\nname: ponytail\n---\n| **lite** | keep lite |\n| **full** | keep full |\n- lite: \"Lite example\"\n- full: \"Full example\"\nOther line`;
 
-    const filtered = filterSkillBodyForMode(body, "ultra");
+    const filtered = filterSkillBodyForMode(body, "lite");
 
-    expect(filtered).not.toContain("keep lite");
+    expect(filtered).toContain("keep lite");
     expect(filtered).not.toContain("keep full");
-    expect(filtered).toContain("keep ultra");
-    expect(filtered).not.toContain("Lite example");
-    expect(filtered).toContain("Ultra example");
+    expect(filtered).toContain("Lite example");
+    expect(filtered).not.toContain("Full example");
     expect(filtered).toContain("Other line");
   });
 
-  it("compact Ponytail instructions retain core rules and mode distinctions", () => {
-    const compact = Object.fromEntries(
-      ["lite", "full", "ultra"].map((mode) => [mode, getPonytailInstructions(mode, { compact: true })]),
-    );
-
-    for (const [mode, instructions] of Object.entries(compact)) {
-      expect(instructions).toMatch(new RegExp(`^PONYTAIL ${mode.toUpperCase()}:`));
-      expect(instructions.length).toBeGreaterThanOrEqual(300);
-      expect(instructions.length).toBeLessThanOrEqual(450);
-      for (const phrase of ["stop ponytail", "Trace first", "root cause", "validation", "data-loss", "security", "accessibility", "runnable check"]) {
-        expect(instructions).toContain(phrase);
-      }
-    }
-
-    expect(compact.lite).toMatch(/Build the ask; name a lazier alternative/);
-    expect(compact.full).toMatch(/Enforce ladder; shortest diff/);
-    expect(compact.ultra).toMatch(/YAGNI first; delete; challenge the rest/);
-
-    const fullSkill = getPonytailInstructions("full");
-    expect(fullSkill).toMatch(/## The ladder/);
-    expect(fullSkill.length).toBeGreaterThan(compact.full.length);
+  it("every mode gets the full skill prompt, filtered to its own intensity row", () => {
+    const lite = getPonytailInstructions("lite");
+    const full = getPonytailInstructions("full");
+
+    expect(lite).toMatch(/^PONYTAIL MODE ACTIVE — level: lite\n\n/);
+    expect(full).toMatch(/^PONYTAIL MODE ACTIVE — level: full\n\n/);
+    for (const text of [lite, full]) expect(text).toMatch(/## The ladder/);
+    expect(lite).toMatch(/\| \*\*lite\*\* \|/);
+    expect(lite).not.toMatch(/\| \*\*full\*\* \|/);
+    expect(full).toMatch(/\| \*\*full\*\* \|/);
+    expect(full).not.toMatch(/\| \*\*lite\*\* \|/);
   });
 
-  it("review instructions remain independent in compact mode", () => {
+  it("review instructions remain independent", () => {
     const expected = "PONYTAIL MODE ACTIVE — level: review. Behavior defined by /ponytail-review skill.";
     expect(getPonytailInstructions("review")).toBe(expected);
-    expect(getPonytailInstructions("review", { compact: true })).toBe(expected);
   });
 
   it("filterSkillBodyForMode keeps rule bullets that contain a colon", () => {
@@ -184,7 +187,7 @@ describe("ponytail helpers", () => {
   });
 
   it("getPonytailInstructions falls back when the skill file is missing", () => {
-    const instructions = getPonytailInstructions("full", { compact: false });
+    const instructions = getPonytailInstructions("full");
     // With the real skill file present this returns the file-based instructions;
     // the fallback path is exercised by deleting the skill file temporarily.
     expect(instructions.length).toBeGreaterThan(0);

package/dist/skills/ponytail/SKILL.md

@@ -6,7 +6,7 @@ description: >
   minimal. Channels a senior dev who has seen everything: question whether the
   task needs to exist at all (YAGNI), reach for the standard library before
   custom code, native platform features before dependencies, one line before
-  fifty. Supports intensity levels: lite, full (default), ultra. Use on ANY
+  fifty. Supports intensity levels: lite, full. Use on ANY
   coding task: writing, adding, refactoring, fixing, reviewing, or designing
   code, and choosing libraries or dependencies. Also use whenever the user
   says "ponytail", "be lazy", "lazy mode", "simplest solution", "minimal
@@ -14,7 +14,7 @@ description: >
   over-engineering, bloat, boilerplate, or unnecessary dependencies. Do NOT
   use for non-coding requests (general knowledge, prose, translation,
   summaries, recipes).
-argument-hint: "[lite|full|ultra]"
+argument-hint: "[off|lite|full]"
 license: MIT
 ---
 
@@ -27,8 +27,8 @@ code is the code never written.
 ## Persistence
 
 ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if
-unsure. Off only: "stop ponytail" / "normal mode". Default: **full**.
-Switch: `/ponytail lite|full|ultra`.
+unsure. Off only: "stop ponytail" / "normal mode".
+Switch: `/ponytail off|lite|full` (your choice is remembered across sessions).
 
 ## The ladder
 
@@ -80,13 +80,11 @@ Pattern: `[code] → skipped: [X], add when [Y].`
 | Level | What change |
 |-------|------------|
 | **lite** | Build what's asked, but name the lazier alternative in one line. User picks. |
-| **full** | The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. Default. |
-| **ultra** | YAGNI extremist. Deletion before addition. Ship the one-liner and challenge the rest of the requirement in the same breath. |
+| **full** | The ladder enforced. Stdlib and native first. Shortest diff, shortest explanation. |
 
 Example: "Add a cache for these API responses."
 - lite: "Done, cache added. FYI: `functools.lru_cache` covers this in one line if you'd rather not own a cache class."
 - full: "`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class, add when lru_cache measurably falls short."
-- ultra: "No cache until a profiler says so. When it does: `@lru_cache`. A hand-rolled TTL cache class is a bug farm with a hit rate."
 
 ## When NOT to be lazy
 

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

@@ -17,10 +17,10 @@ write flag files, or persist anything.
 | Level | Trigger | What change |
 |-------|---------|-------------|
 | **Lite** | `/ponytail lite` | Build what's asked, name the lazier alternative in one line. |
-| **Full** | `/ponytail` | The ladder enforced: YAGNI → stdlib → native → one line → minimum. Default. |
-| **Ultra** | `/ponytail ultra` | YAGNI extremist. Deletion before addition. Challenges requirements before building. |
+| **Full** | `/ponytail` or `/ponytail full` | The ladder enforced: YAGNI → stdlib → native → one line → minimum. |
+| **Off** | `/ponytail off` | Ponytail disabled. |
 
-Level sticks until changed or session end.
+Your choice is remembered: new sessions (and handoffs) start in the last mode you picked.
 
 ## Skills
 
@@ -44,20 +44,16 @@ Say "stop ponytail" or "normal mode". Resume anytime with `/ponytail`.
 
 ## 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`):
+Off until you pick a mode. Picking one with `/ponytail <mode>` saves it to the
+agent `settings.json` (`~/.selesai/agent/settings.json`):
 ```json
-{ "defaultMode": "lite" }
+{ "ponytailMode": "lite" }
 ```
 
-Set `"off"` to disable auto-activation on session start, activate manually
-with `/ponytail` when wanted.
+**Environment variable** (overrides settings.json):
+```bash
+export PONYTAIL_DEFAULT_MODE=lite
+```
 
 Resolution: env var > config file > `full`.
 

package/docs/settings.md

@@ -67,12 +67,14 @@ routing. The host-side routes stay off until they are enabled in `jevAdvisory`;
   of the agent's loadout before each run (it returns after `/tokenin add`, no reload needed), and a call
   that slips through reads no file and runs no command.
 
-  The same route also offers `jev_find`, a file finder: ripgrep gathers up to 48 candidate files
-  (those matching `pattern`, or every file under `path` filtered by `glob`, ranked by question words),
-  Jev judges each file's best-matching lines against the agent's `question` in parallel batches of 16,
-  and the agent gets ranked `path:lines (relevance)` pointers — never file contents. It respects
-  `.gitignore`, stays inside the working directory, skips secret-named files, and still returns the
-  unranked candidates when Jev is unavailable.
+  The same route also offers `jev_find`, a behavior finder: ripgrep gathers candidate files (those
+  matching `pattern`, or every file under `path` filtered by `glob`); on large trees Jev first judges
+  directories and descends only into relevant ones, then judges files, then the declarations (source
+  units) inside relevant files. The agent gets a ranked file list with reading leads plus the accepted
+  units verbatim with original line numbers (at most 12 Jev requests and 16 KiB of source per call).
+  It respects `.gitignore`, stays inside the working directory, skips secret-named files, retries a
+  transport failure once, and still returns ripgrep-ranked candidates with keyword-window source when
+  Jev is unavailable.
 - `subagent` — sets up a single-child `subagent` call from the parent agent (off by default). Jev only
   fills what the parent left open, and can only narrow: (1) when `agent` is omitted or generic
   (`genericAgents`, default `["delegate"]`), it picks an agent by function from enabled native agents

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.35",
+  "version": "0.13.38",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "engines": {