@selesai/code 0.13.35 → 0.13.37

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.37] - 2026-09-30
+
+### Changed
+- **Ponytail starts in `lite` by default.** With no `PONYTAIL_DEFAULT_MODE` and no `ponytailMode` in the agent `settings.json`, new sessions and handoffs now start in `lite` instead of `off`. A saved choice still wins: `/ponytail off` (or `/ponytail default off`) keeps it off.
+
+## [0.13.36] - 2026-09-29
+
+### Fixed
+- **Remote model catalogs load again.** The pi.dev catalog request identified itself as `pi/<selesai version>`, and pi.dev answers an unknown Pi version with 404 ("No compatible model catalog is available for this Pi version"). Selesai cached that as an empty catalog, so models newer than the bundled data — such as `openai-codex/gpt-6-sol`, `openai-codex/gpt-6-luna`, and `github-copilot/gpt-6-luna` — showed as `[unavailable]` in the model list even when logged in. The request now carries the upstream Pi platform version (`PI_PLATFORM_VERSION`, the pinned `@earendil-works/pi-ai` release). An existing empty entry in `models-store.json` is refetched after its 4-hour window, or immediately if you delete it.
+
+### Changed
+- **Ponytail is off by default and remembers your mode.** Opt in with `/ponytail`. `/ponytail <mode>` saves the choice as `ponytailMode` in the agent `settings.json`, so new sessions and handoffs start in it; other keys are preserved and an unparseable `settings.json` is never overwritten. Modes are `off`, `lite`, and `full` (`ultra` was removed), and every mode now gets upstream's full ponytail prompt.
+
 ## [0.13.35] - 2026-09-29
 
 ### Added

package/dist/config.d.ts

@@ -92,6 +92,8 @@ export declare const APP_NAME: string;
 export declare const APP_TITLE: string;
 export declare const CONFIG_DIR_NAME: string;
 export declare const VERSION: string;
+/** Upstream Pi platform version (the pinned pi-ai release). pi.dev gates model catalogs on this, not on VERSION. */
+export declare const PI_PLATFORM_VERSION: string;
 export declare const ENV_AGENT_DIR: string;
 export declare const ENV_SESSION_DIR: string;
 export declare function expandTildePath(path: string): string;

package/dist/config.js

@@ -463,6 +463,8 @@ export const APP_NAME = piConfigName || "pi";
 export const APP_TITLE = piConfigName ? APP_NAME : "π";
 export const CONFIG_DIR_NAME = pkg.piConfig?.configDir || ".pi";
 export const VERSION = pkg.version || "0.0.0";
+/** Upstream Pi platform version (the pinned pi-ai release). pi.dev gates model catalogs on this, not on VERSION. */
+export const PI_PLATFORM_VERSION = pkg.dependencies?.["@earendil-works/pi-ai"]?.replace(/^[^\d]*/, "") || VERSION;
 // e.g., PI_CODING_AGENT_DIR or TAU_CODING_AGENT_DIR
 export const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
 export const ENV_SESSION_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_SESSION_DIR`;

package/dist/core/remote-catalog-provider.js

@@ -1,4 +1,4 @@
-import { VERSION } from "../config.js";
+import { PI_PLATFORM_VERSION } from "../config.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 const DEFAULT_CATALOG_BASE_URL = "https://pi.dev";
 export const REMOTE_CATALOG_REFRESH_INTERVAL_MS = 4 * 60 * 60 * 1000;
@@ -70,7 +70,7 @@ export function withRemoteCatalog(provider, catalogBaseUrl = DEFAULT_CATALOG_BAS
             const response = await fetch(url, {
                 headers: {
                     accept: "application/json",
-                    "User-Agent": getPiUserAgent(VERSION),
+                    "User-Agent": getPiUserAgent(PI_PLATFORM_VERSION),
                     ...(validator ? { "if-none-match": validator } : {}),
                 },
                 signal: context.signal,

package/dist/core/remote-catalog-provider.test.js

@@ -1,4 +1,5 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
+import { PI_PLATFORM_VERSION, VERSION } from "../config.js";
 import { withRemoteCatalog } from "./remote-catalog-provider.js";
 const cachedModel = {
     id: "gpt-6-sol",
@@ -26,4 +27,22 @@ describe("remote model catalog cache", () => {
         await wrapped.refreshModels?.(refreshContext({ models: [cachedModel], checkedAt: localGeneratedAt + 1, lastModified: 0 }));
         expect(wrapped.getModels().map((model) => model.id)).toEqual(["gpt-6-sol"]);
     });
+    // pi.dev 404s catalogs for unknown Pi versions; selesai's own VERSION is not a Pi version.
+    it("identifies as the upstream Pi platform version, not the selesai version", async () => {
+        expect(PI_PLATFORM_VERSION).not.toBe(VERSION);
+        const fetchMock = vi.fn(async () => new Response("{}", { status: 200 }));
+        vi.stubGlobal("fetch", fetchMock);
+        try {
+            const provider = { id: "openai-codex", getModels: () => [] };
+            await withRemoteCatalog(provider, "https://example.test").refreshModels?.({
+                ...refreshContext(undefined),
+                allowNetwork: true,
+            });
+            const headers = fetchMock.mock.calls[0][1].headers;
+            expect(headers["User-Agent"]).toMatch(new RegExp(`^pi/${PI_PLATFORM_VERSION.replaceAll(".", "\\.")} `));
+        }
+        finally {
+            vi.unstubAllGlobals();
+        }
+    });
 });

package/dist/extensions/ponytail/index.js

@@ -68,6 +68,12 @@ export default function ponytailExtension(pi) {
 
     currentMode = normalized;
     pi.appendEntry("ponytail-mode", { mode: normalized });
+    // Remember the choice for future sessions (new chats, handoffs) too.
+    try {
+      if (writeDefaultMode(normalized)) configuredDefaultMode = getDefaultMode();
+    } catch (_) {
+      // ponytail: unwritable config just means this session-only; not worth failing the command.
+    }
     ctx?.ui?.notify?.(`Ponytail mode set to ${normalized}.`, "info");
   };
 
@@ -168,9 +174,6 @@ export default function ponytailExtension(pi) {
     // 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` : "";
-    // ponytail: full keeps the detailed skill; alternate modes use the compact
-    // ruleset to avoid repeating the same system prompt on every request.
-    const compact = currentMode !== "full";
-    return { systemPrompt: `${base}${getPonytailInstructions(currentMode, { compact })}` };
+    return { systemPrompt: `${base}${getPonytailInstructions(currentMode)}` };
   });
 }

package/dist/extensions/ponytail/ponytail-config.cjs

@@ -3,19 +3,20 @@
 //
 // Resolution order for default mode:
 //   1. PONYTAIL_DEFAULT_MODE environment variable
-//   2. Config file defaultMode field:
-//      - $XDG_CONFIG_HOME/ponytail/config.json (any platform, if set)
-//      - ~/.config/ponytail/config.json (macOS / Linux fallback)
-//      - %APPDATA%\ponytail\config.json (Windows fallback)
-//   3. 'full'
+//   2. "ponytailMode" in the agent settings.json
+//      ($SELESAI_CODING_AGENT_DIR/settings.json, else ~/.selesai/agent/settings.json)
+//   3. 'lite' (built-in default)
+//
+// quietStartup still lives in the standalone ponytail config.json (getConfigPath).
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const DEFAULT_MODE = 'full';
-const VALID_MODES = ['off', 'lite', 'full', 'ultra', 'review'];
-const RUNTIME_MODES = ['off', 'lite', 'full', 'ultra'];
+const DEFAULT_MODE = 'lite';
+const VALID_MODES = ['off', 'lite', 'full', 'review'];
+const RUNTIME_MODES = ['off', 'lite', 'full'];
+const SETTINGS_KEY = 'ponytailMode';
 
 function normalizeMode(mode) {
   if (typeof mode !== 'string') return null;
@@ -73,26 +74,49 @@ function getClaudeDir() {
   return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
 }
 
+// ponytail: mirrors getAgentDir() in src/config.ts with the "selesai" app name
+// hardcoded (this CJS file can't import the TS config). Revisit if the fork is renamed.
+function getSettingsPath() {
+  const envDir = process.env.SELESAI_CODING_AGENT_DIR;
+  const agentDir = envDir
+    ? envDir.replace(/^~(?=$|[\\/])/, os.homedir())
+    : path.join(os.homedir(), '.selesai', 'agent');
+  return path.join(agentDir, 'settings.json');
+}
+
+// Returns {} when the file is missing; throws on unreadable/invalid JSON so a
+// write never replaces a settings file we couldn't parse.
+function readSettings() {
+  let raw;
+  try {
+    raw = fs.readFileSync(getSettingsPath(), 'utf8');
+  } catch (e) {
+    if (e.code === 'ENOENT') return {};
+    throw e;
+  }
+  const parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('settings.json is not a JSON object');
+  }
+  return parsed;
+}
+
 function getDefaultMode() {
   // 1. Environment variable (highest priority)
   const envMode = process.env.PONYTAIL_DEFAULT_MODE;
-  // ponytail: a default must be a runtime level (off/lite/full/ultra); review is
+  // ponytail: a default must be a runtime level (off/lite/full); review is
   // a session-only mode, never a valid default (#377). Validate against
   // RUNTIME_MODES so a stray env var or config can't make review the default.
   if (envMode && RUNTIME_MODES.includes(envMode.toLowerCase())) {
     return envMode.toLowerCase();
   }
 
-  // 2. Config file
+  // 2. settings.json
   try {
-    const configPath = getConfigPath();
-    // Strip UTF-8 BOM (common on Windows-saved files) so JSON.parse doesn't choke
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8').replace(/^\uFEFF/, ''));
-    if (config.defaultMode && RUNTIME_MODES.includes(config.defaultMode.toLowerCase())) {
-      return config.defaultMode.toLowerCase();
-    }
+    const mode = normalizeMode(readSettings()[SETTINGS_KEY]);
+    if (mode) return mode;
   } catch (e) {
-    // Config file doesn't exist or is invalid — fall through
+    // Unreadable or invalid settings — fall through
   }
 
   // 3. Default
@@ -121,15 +145,16 @@ function writeDefaultMode(mode) {
   const normalized = normalizeMode(mode);
   if (!normalized) return null;
 
-  const configPath = getConfigPath();
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  let config = {};
-  try {
-    config = JSON.parse(fs.readFileSync(configPath, 'utf8').replace(/^\uFEFF/, ''));
-    if (!config || typeof config !== 'object' || Array.isArray(config)) config = {};
-  } catch (_) {}
-  config.defaultMode = normalized;
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+  // Keep every other key; readSettings throws rather than letting us clobber a
+  // file we couldn't parse.
+  // ponytail: no lock shared with SettingsManager. Its saves re-read the file and
+  // merge, so our key survives; only a same-millisecond concurrent write could race.
+  const settingsPath = getSettingsPath();
+  const settings = readSettings();
+  if (settings[SETTINGS_KEY] === normalized) return normalized;
+  settings[SETTINGS_KEY] = normalized;
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
   return normalized;
 }
 
@@ -140,6 +165,7 @@ module.exports = {
   getDefaultMode,
   getConfigDir,
   getConfigPath,
+  getSettingsPath,
   getClaudeDir,
   getQuietStartup,
   isShellSafe,

package/dist/extensions/ponytail/ponytail-instructions.cjs

@@ -6,11 +6,6 @@ const path = require('path');
 const { DEFAULT_MODE, normalizeMode, normalizePersistedMode } = require('./ponytail-config.cjs');
 
 const INDEPENDENT_MODES = new Set(['review']);
-const COMPACT_MODE_RULES = {
-  lite: 'Build the ask; name a lazier alternative.',
-  full: 'Enforce ladder; shortest diff.',
-  ultra: 'YAGNI first; delete; challenge the rest.',
-};
 const SKILL_PATH = path.join(__dirname, '..', '..', 'skills', 'ponytail', 'SKILL.md');
 
 function filterSkillBodyForMode(body, mode) {
@@ -18,7 +13,7 @@ function filterSkillBodyForMode(body, mode) {
   const withoutFrontmatter = String(body || '').replace(/^---[\s\S]*?---\s*/, '');
 
   // Only the intensity table rows and worked examples are mode-specific, and
-  // both are keyed by a mode name (lite/full/ultra). A bullet whose label is
+  // both are keyed by a mode name (lite/full). A bullet whose label is
   // not a mode — e.g. "No unrequested abstractions: ..." — is a normal rule
   // and must be kept verbatim.
   return withoutFrontmatter
@@ -50,7 +45,7 @@ function getFallbackInstructions(mode) {
     'You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.\n\n' +
     '## Persistence\n\n' +
     'ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure. Off only: "stop ponytail" / "normal mode".\n\n' +
-    'Current level: **' + mode + '**. Switch: `/ponytail lite|full|ultra`.\n\n' +
+    'Current level: **' + mode + '**. Switch: `/ponytail off|lite|full`.\n\n' +
     '## The ladder\n\n' +
     'Before any code, stop at the first rung that holds (the ladder runs after you understand the problem, not instead of it — read the code it touches and trace the real flow first):\n' +
     '1. Does this need to be built at all? (YAGNI)\n' +
@@ -79,15 +74,7 @@ function getFallbackInstructions(mode) {
     'Ponytail governs what you build, not how you talk. "stop ponytail" or "normal mode": revert. Level persists until changed or session end.';
 }
 
-function getCompactInstructions(mode) {
-  return 'PONYTAIL ' + mode.toUpperCase() + ': persistent every response; off only "stop ponytail"/"normal mode". ' +
-    'Trace first. Ladder: YAGNI -> reuse -> stdlib/native -> installed deps -> minimum diff. ' +
-    'Fix root cause, not caller symptom. No unrequested abstractions/deps/boilerplate; delete first. ' +
-    'Preserve validation, data-loss handling, security, accessibility, explicit asks. ' +
-    'Non-trivial logic: one runnable check. Code first; <=3 lines. ' + COMPACT_MODE_RULES[mode];
-}
-
-function getPonytailInstructions(mode, options) {
+function getPonytailInstructions(mode) {
   const configuredMode = normalizePersistedMode(mode) || DEFAULT_MODE;
 
   if (INDEPENDENT_MODES.has(configuredMode)) {
@@ -95,7 +82,6 @@ function getPonytailInstructions(mode, options) {
   }
 
   const effectiveMode = normalizeMode(configuredMode) || DEFAULT_MODE;
-  if (options?.compact === true) return getCompactInstructions(effectiveMode);
 
   try {
     return 'PONYTAIL MODE ACTIVE — level: ' + effectiveMode + '\n\n' +

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

@@ -42,13 +42,17 @@ function createCommandContext(overrides = {}) {
 function withTempConfig(fn) {
 	const tempConfigHome = mkdtempSync(join(tmpdir(), "ponytail-test-"));
 	const previousXdg = process.env.XDG_CONFIG_HOME;
+	const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
 	process.env.XDG_CONFIG_HOME = tempConfigHome;
+	process.env.SELESAI_CODING_AGENT_DIR = tempConfigHome;
 
 	return Promise.resolve()
 		.then(fn)
 		.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;
 			rmSync(tempConfigHome, { recursive: true, force: true });
 		});
 }
@@ -65,15 +69,32 @@ describe("ponytail extension", () => {
 		const ctx = createCommandContext();
 
 		await events.get("session_start")({ reason: "startup" }, ctx);
-		await commands.get("ponytail").handler("ultra", ctx);
+		await commands.get("ponytail").handler("lite", ctx);
 
 		expect(appendedEntries.at(-1)).toEqual({
 			customType: "ponytail-mode",
-			data: { mode: "ultra" },
+			data: { mode: "lite" },
 		});
 
 		const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
-		expect(result.systemPrompt).toMatch(/^BASE\n\nPONYTAIL ULTRA:/);
+		expect(result.systemPrompt).toMatch(/^BASE\n\nPONYTAIL MODE ACTIVE — level: lite\n/);
+	}));
+
+	it("/ponytail <mode> carries into brand-new sessions", async () => withTempConfig(async () => {
+		const first = createPiHarness();
+		await first.events.get("session_start")({ reason: "startup" }, createCommandContext());
+		await first.commands.get("ponytail").handler("lite", createCommandContext());
+
+		// Fresh extension instance + empty session, like a new chat or handoff.
+		const next = createPiHarness();
+		await next.events.get("session_start")({ reason: "new" }, createCommandContext());
+		const result = await next.events.get("before_agent_start")({ systemPrompt: "BASE" }, createCommandContext());
+		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: lite\n/);
+
+		await next.commands.get("ponytail").handler("off", createCommandContext());
+		const after = createPiHarness();
+		await after.events.get("session_start")({ reason: "new" }, createCommandContext());
+		expect(await after.events.get("before_agent_start")({ systemPrompt: "BASE" }, createCommandContext())).toBeUndefined();
 	}));
 
 	it("session_start restores latest persisted mode", async () => withTempConfig(async () => {
@@ -89,7 +110,7 @@ describe("ponytail extension", () => {
 		await events.get("session_start")({ reason: "resume" }, ctx);
 		const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
 
-		expect(result.systemPrompt).toMatch(/PONYTAIL LITE:/);
+		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: lite\n/);
 	}));
 
 	it("review mode retains its independent skill prompt", async () => withTempConfig(async () => {
@@ -140,7 +161,7 @@ describe("ponytail extension", () => {
 		const ctx = createCommandContext();
 
 		await events.get("session_start")({ reason: "startup" }, ctx);
-		await commands.get("ponytail").handler("ultra", ctx);
+		await commands.get("ponytail").handler("lite", ctx);
 		await events.get("input")({ text: "normal mode", source: "interactive" }, ctx);
 
 		const disabled = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
@@ -152,11 +173,11 @@ describe("ponytail extension", () => {
 		const ctx = createCommandContext();
 
 		await events.get("session_start")({ reason: "startup" }, ctx);
-		await commands.get("ponytail").handler("ultra", ctx);
+		await commands.get("ponytail").handler("lite", 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);
-		expect(result.systemPrompt).toMatch(/PONYTAIL ULTRA:/);
+		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: lite\n/);
 	}));
 
 	it("never writes a Ponytail statusline", async () => withTempConfig(async () => {
@@ -179,7 +200,7 @@ describe("ponytail extension", () => {
 
 		await events.get("session_start")({ reason: "startup" }, ctx);
 		await commands.get("ponytail").handler("status", ctx);
-		expect(notifications.at(-1).msg).toContain("Ponytail: current full • default full");
+		expect(notifications.at(-1).msg).toContain("Ponytail: current lite • default lite");
 	}));
 
 	it("/ponytail set-default persists the default mode", async () => withTempConfig(async () => {
@@ -194,7 +215,7 @@ describe("ponytail extension", () => {
 
 	it("/ponytail set-default with env override reports the override", async () => withTempConfig(async () => {
 		const previous = process.env.PONYTAIL_DEFAULT_MODE;
-		process.env.PONYTAIL_DEFAULT_MODE = "ultra";
+		process.env.PONYTAIL_DEFAULT_MODE = "full";
 		try {
 			const { commands, events } = createPiHarness();
 			const notifications = [];
@@ -202,7 +223,7 @@ describe("ponytail extension", () => {
 
 			await events.get("session_start")({ reason: "startup" }, ctx);
 			await commands.get("ponytail").handler("default lite", ctx);
-			expect(notifications.at(-1).msg).toContain("env override keeps default at ultra");
+			expect(notifications.at(-1).msg).toContain("env override keeps default at full");
 		} finally {
 			if (previous === undefined) delete process.env.PONYTAIL_DEFAULT_MODE;
 			else process.env.PONYTAIL_DEFAULT_MODE = previous;
@@ -224,11 +245,11 @@ describe("ponytail extension", () => {
 		const ctx = createCommandContext();
 
 		await events.get("session_start")({ reason: "startup" }, ctx);
-		await commands.get("ponytail").handler("ultra", ctx);
+		await commands.get("ponytail").handler("lite", ctx);
 		await events.get("input")({ text: "normal mode", source: "extension" }, ctx);
 
 		const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
-		expect(result.systemPrompt).toMatch(/PONYTAIL ULTRA:/);
+		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: lite\n/);
 	}));
 
 	it("setMode ignores invalid modes", async () => withTempConfig(async () => {
@@ -252,7 +273,7 @@ describe("ponytail extension", () => {
 
 		await events.get("session_start")({ reason: "resume" }, ctx);
 		const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
-		expect(result.systemPrompt).toMatch(/PONYTAIL LITE:/);
+		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: lite\n/);
 	}));
 
 	it("session_start tolerates a missing sessionManager", async () => withTempConfig(async () => {
@@ -261,7 +282,7 @@ describe("ponytail extension", () => {
 
 		await events.get("session_start")({ reason: "resume" }, ctx);
 		const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
-		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: full/);
+		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: lite\n/); // default is lite
 	}));
 
 	it("input handler tolerates missing text", async () => withTempConfig(async () => {
@@ -269,11 +290,11 @@ describe("ponytail extension", () => {
 		const ctx = createCommandContext();
 
 		await events.get("session_start")({ reason: "startup" }, ctx);
-		await commands.get("ponytail").handler("ultra", ctx);
+		await commands.get("ponytail").handler("lite", ctx);
 		await events.get("input")({ source: "interactive" }, ctx);
 
 		const result = await events.get("before_agent_start")({ systemPrompt: "BASE" }, ctx);
-		expect(result.systemPrompt).toMatch(/PONYTAIL ULTRA:/);
+		expect(result.systemPrompt).toMatch(/PONYTAIL MODE ACTIVE — level: lite\n/);
 	}));
 
 	it("setMode notifies when ctx has a UI", async () => withTempConfig(async () => {

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/package.json

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