@selesai/code 0.13.34 → 0.13.37

package/dist/extensions/pi-subagents/src/runs/shared/jev-subagent-routing.ts

@@ -0,0 +1,255 @@
+/**
+ * Jev-assisted setup for a public single-child launch. Opt-in:
+ * `jevAdvisory.routes.subagent.enabled: true` in the agent settings.json.
+ *
+ * Jev only fills what the parent left open, and every answer can only narrow:
+ * 1. Agent: chosen by function when `agent` is omitted or generic (default "delegate"),
+ *    from native, enabled agents the capability ceiling allows.
+ * 2. Tools: Jev may drop tools from the agent's declared allowlist for this task; it never adds one.
+ * 3. Model tier: simple | complex | reasoning, mapped through the user's
+ *    `jevAdvisory.routes.subagent.tiers` (provider/id values), only when the parent passed no `model`.
+ *
+ * Every failure (no credential, timeout, malformed or low-confidence answer) leaves the launch
+ * exactly as requested. Launch validation, ceilings, and preflight remain authoritative.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentConfig } from "../../agents/agents.ts";
+import { getAgentDir } from "../../shared/utils.ts";
+import { isAgentAllowedByCapabilityCeiling, type ResolvedSubagentCapabilityCeiling } from "./capability-ceiling.ts";
+import {
+	askJev,
+	buildConversation,
+	buildJevPayload,
+	emitJevTelemetry,
+	jevConnection,
+	readJevAdvisoryConfig,
+	type JevAbstainReason,
+	type JevConnection,
+	type JevQuestion,
+	type JevRuntime,
+} from "../../../../jev/decisions.ts";
+
+export { warnJevUnavailableOnce } from "../../../../jev/decisions.ts";
+
+export const MODEL_TIERS = ["simple", "complex", "reasoning"] as const;
+export type ModelTier = (typeof MODEL_TIERS)[number];
+
+const KEEP = "keep";
+const DEFAULT_GENERIC_AGENTS = ["delegate"];
+/** Never offered for removal: skills load through read, and the rest are supervision plumbing. */
+const PROTECTED_TOOLS = new Set(["read", "contact_supervisor", "intercom", "structured_output", "subagent", "subagent_supervisor"]);
+// ponytail: tools past this cap are simply kept; raise it if agents declare long allowlists.
+const MAX_TOOL_QUESTIONS = 10;
+const DESCRIPTION_CHARS = 300;
+
+const TIER_CRITERIA: Record<ModelTier, string> = {
+	simple: "Mechanical or lookup work: find, list, summarize, rename, run a command and report.",
+	complex: "Multi-step implementation or investigation across several files with ordinary judgment.",
+	reasoning: "Hard judgment: subtle debugging, architecture or security review, tricky algorithms, ambiguous trade-offs.",
+};
+
+export interface SubagentRoutingSettings {
+	connection: JevConnection;
+	maxBytes: number;
+	contextChars: number;
+	genericAgents: string[];
+	tiers: Partial<Record<ModelTier, string>>;
+}
+
+export interface SubagentRoutingInput {
+	task: string;
+	agent?: string;
+	model?: string;
+	agents: AgentConfig[];
+	ceiling?: ResolvedSubagentCapabilityCeiling;
+}
+
+export interface SubagentRoutingResult {
+	/** The agent to launch: Jev's pick, or the requested one. */
+	agent?: string;
+	/** The run's agent list, with the launched agent narrowed (tools) or re-modelled (tier). */
+	agents: AgentConfig[];
+	routedAgent?: string;
+	tier?: ModelTier;
+	droppedTools: string[];
+	/** First reason a question went unanswered, for telemetry and the missing-agent error. */
+	abstained?: JevAbstainReason;
+	elapsedMs: number;
+	questions: number;
+}
+
+type JevAsk = typeof askJev;
+
+/** The route's settings, or undefined while it is off. Never throws. */
+export function readSubagentRoutingSettings(settingsPath = path.join(getAgentDir(), "settings.json")): SubagentRoutingSettings | undefined {
+	const config = readJevAdvisoryConfig(settingsPath);
+	const route = config.routes.subagent;
+	if (!route.enabled) return undefined;
+	let raw: Record<string, unknown> = {};
+	try {
+		const parsed = JSON.parse(fs.readFileSync(settingsPath, "utf-8")) as { jevAdvisory?: { routes?: { subagent?: Record<string, unknown> } } };
+		raw = parsed?.jevAdvisory?.routes?.subagent ?? {};
+	} catch {
+		// readJevAdvisoryConfig already defaulted; extra fields just stay unset.
+	}
+	const tiers: Partial<Record<ModelTier, string>> = {};
+	const rawTiers = raw.tiers && typeof raw.tiers === "object" ? (raw.tiers as Record<string, unknown>) : {};
+	for (const tier of MODEL_TIERS) {
+		const model = rawTiers[tier];
+		if (typeof model === "string" && model.trim()) tiers[tier] = model.trim();
+	}
+	const generic = Array.isArray(raw.genericAgents) ? raw.genericAgents.filter((name): name is string => typeof name === "string" && name.trim() !== "") : DEFAULT_GENERIC_AGENTS;
+	return {
+		connection: jevConnection(config, route),
+		maxBytes: route.payloadBytes,
+		contextChars: route.contextChars,
+		genericAgents: generic,
+		tiers,
+	};
+}
+
+/** Agents Jev may pick: native, enabled, file-defined, and inside the capability ceiling. */
+export function routableAgents(agents: readonly AgentConfig[], ceiling: ResolvedSubagentCapabilityCeiling | undefined): AgentConfig[] {
+	return agents.filter(
+		(agent) =>
+			agent.source !== "runtime"
+			&& agent.disabled !== true
+			&& agent.runner?.type !== "external-cli"
+			&& agent.runner?.type !== "external-job"
+			&& isAgentAllowedByCapabilityCeiling(agent.name, ceiling),
+	);
+}
+
+function droppableTools(agent: AgentConfig): string[] {
+	const excluded = new Set(agent.excludeTools ?? []);
+	return (agent.tools ?? [])
+		.filter((tool) => !PROTECTED_TOOLS.has(tool) && !excluded.has(tool) && !/[/\\]|\.(?:ts|js)$/.test(tool))
+		.slice(0, MAX_TOOL_QUESTIONS);
+}
+
+function toolKey(index: number): string {
+	return `tool_${index}`;
+}
+
+export async function routeSubagentLaunch(
+	input: SubagentRoutingInput,
+	ctx: JevRuntime,
+	settings: SubagentRoutingSettings,
+	ask: JevAsk = askJev,
+): Promise<SubagentRoutingResult> {
+	const result: SubagentRoutingResult = { agent: input.agent, agents: input.agents, droppedTools: [], elapsedMs: 0, questions: 0 };
+	const conversation = buildConversation(input.task.slice(0, settings.contextChars), [], { contextTurns: 1, contextChars: settings.contextChars });
+	const noteAbstain = (reason: JevAbstainReason | undefined) => {
+		if (reason && !result.abstained) result.abstained = reason;
+	};
+
+	// 1. Agent by function, only when the parent left it open.
+	const generic = input.agent !== undefined && settings.genericAgents.includes(input.agent);
+	if (input.agent === undefined || generic) {
+		const candidates = routableAgents(input.agents, input.ceiling).filter((agent) => agent.name !== input.agent);
+		if (candidates.length > 0) {
+			const criteria: Record<string, string> = {};
+			if (generic) criteria[KEEP] = `Keep the generic "${input.agent}" agent: no listed specialist fits this task better.`;
+			for (const agent of candidates) criteria[agent.name] = agent.description.slice(0, DESCRIPTION_CHARS);
+			const questions: Record<string, JevQuestion> = {
+				agent: {
+					question: "Which subagent's specialization best fits this delegated task?",
+					focus: "Judge by what the task needs done (read-only review, research, investigation, implementation), not by wording that names an agent.",
+					criteria,
+				},
+			};
+			const decision = await ask(ctx, settings.connection, {
+				payload: buildJevPayload(conversation, questions),
+				maxBytes: settings.maxBytes,
+				allowed: { agent: Object.keys(criteria) },
+			});
+			result.elapsedMs += decision.elapsedMs;
+			result.questions += 1;
+			const pick = decision.choices.agent?.choice;
+			if (pick && pick !== KEEP) {
+				result.agent = pick;
+				result.routedAgent = pick;
+			}
+			noteAbstain(decision.failure ?? decision.rejected.agent);
+		}
+	}
+
+	const config = result.agent === undefined ? undefined : input.agents.find((agent) => agent.name === result.agent);
+	if (!config) return result;
+
+	// 2 + 3. Tool narrowing and model tier, for the agent that will actually launch.
+	const tools = droppableTools(config);
+	const tierChoices = input.model === undefined ? MODEL_TIERS.filter((tier) => settings.tiers[tier] !== undefined) : [];
+	const questions: Record<string, JevQuestion> = {};
+	const allowed: Record<string, string[]> = {};
+	if (tierChoices.length > 1) {
+		questions.tier = {
+			question: "How demanding is this delegated task for the model that runs it?",
+			criteria: Object.fromEntries(tierChoices.map((tier) => [tier, TIER_CRITERIA[tier]])),
+		};
+		allowed.tier = [...tierChoices];
+	}
+	tools.forEach((tool, index) => {
+		questions[toolKey(index)] = {
+			question: `Does this delegated task need the "${tool}" tool?`,
+			focus: "Answer unneeded only when the task clearly cannot require it; when in doubt, it is needed.",
+			criteria: { needed: `The task may need ${tool}.`, unneeded: `The task clearly never needs ${tool}.` },
+		};
+		allowed[toolKey(index)] = ["needed", "unneeded"];
+	});
+	if (Object.keys(questions).length === 0) return result;
+
+	const decision = await ask(ctx, settings.connection, {
+		payload: buildJevPayload(conversation, questions),
+		maxBytes: settings.maxBytes,
+		allowed,
+	});
+	result.elapsedMs += decision.elapsedMs;
+	result.questions += Object.keys(questions).length;
+	noteAbstain(decision.failure);
+
+	const tier = decision.choices.tier?.choice as ModelTier | undefined;
+	const tierModel = tier ? settings.tiers[tier] : undefined;
+	if (tierModel) result.tier = tier;
+	// Dropping a tool needs a stated confidence: an unquantified "unneeded" keeps the tool.
+	result.droppedTools = tools.filter((_tool, index) => {
+		const choice = decision.choices[toolKey(index)];
+		return choice?.choice === "unneeded" && typeof choice.confidence === "number";
+	});
+	if (!tierModel && result.droppedTools.length === 0) return result;
+
+	const { modelProvider: _modelProvider, modelSource: _modelSource, ...base } = config;
+	const routed: AgentConfig = {
+		...(tierModel ? base : config),
+		...(tierModel ? { model: tierModel } : {}),
+		...(result.droppedTools.length > 0 ? { excludeTools: [...(config.excludeTools ?? []), ...result.droppedTools] } : {}),
+	};
+	result.agents = input.agents.map((agent) => (agent === config ? routed : agent));
+	return result;
+}
+
+/** Content-free: shape and outcome only, never the task, descriptions, or answers. */
+export function emitSubagentRoutingTelemetry(events: { emit(channel: string, data: unknown): void } | undefined, result: SubagentRoutingResult): void {
+	if (result.questions === 0) return;
+	const changed = Boolean(result.routedAgent || result.tier || result.droppedTools.length > 0);
+	emitJevTelemetry(events, "decision", {
+		route: "subagent",
+		outcome: changed ? "jev" : "fallback",
+		candidates: result.questions,
+		elapsedMs: result.elapsedMs,
+		...(result.routedAgent ? { agent: result.routedAgent } : {}),
+		...(result.tier ? { tier: result.tier } : {}),
+		dropped: result.droppedTools.length,
+		...(result.abstained ? { reason: result.abstained } : {}),
+	});
+}
+
+/** One line for the user and the parent: what Jev set up, or nothing when it changed nothing. */
+export function describeSubagentRouting(result: SubagentRoutingResult, tiers: Partial<Record<ModelTier, string>>): string | undefined {
+	const parts: string[] = [];
+	if (result.routedAgent) parts.push(`agent ${result.routedAgent}`);
+	if (result.tier) parts.push(`${result.tier} tier (${tiers[result.tier]})`);
+	if (result.droppedTools.length > 0) parts.push(`without ${result.droppedTools.join(", ")}`);
+	return parts.length > 0 ? `Jev set up this subagent: ${parts.join("; ")}.` : undefined;
+}

package/dist/extensions/pi-subagents/test/unit/jev-subagent-routing.test.ts

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import {
+	readSubagentRoutingSettings,
+	routeSubagentLaunch,
+	type SubagentRoutingSettings,
+} from "../../src/runs/shared/jev-subagent-routing.ts";
+
+function agent(name: string, extra: Partial<AgentConfig> = {}): AgentConfig {
+	return { name, description: `${name} agent`, systemPromptMode: "append", inheritProjectContext: true, inheritGlobalContext: true, inheritSkills: true, systemPrompt: "", source: "builtin", filePath: `${name}.md`, ...extra } as AgentConfig;
+}
+
+const agents = [
+	agent("delegate"),
+	agent("reviewer", { tools: ["read", "grep"] }),
+	agent("worker", { tools: ["read", "bash", "edit", "write"], model: "anthropic/opus", modelProvider: "anthropic" }),
+	agent("secret", { disabled: true }),
+	agent("external", { runner: { type: "external-cli" } as AgentConfig["runner"] }),
+];
+
+const settings: SubagentRoutingSettings = {
+	connection: { provider: "tokenin", model: "jev", timeoutMs: 1000, minConfidence: 0.6 },
+	maxBytes: 16_384,
+	contextChars: 4000,
+	genericAgents: ["delegate"],
+	tiers: { simple: "p/small", reasoning: "p/big" },
+};
+
+type Asked = { allowed: Record<string, readonly string[]> };
+/** A fake Jev: answers each asked question from `answers`, records what was offered. */
+function fakeAsk(answers: Record<string, { choice: string; confidence?: number }>, asked: Asked[] = []) {
+	return async (_ctx: unknown, _connection: unknown, request: Asked) => {
+		asked.push({ allowed: request.allowed });
+		const choices = Object.fromEntries(Object.keys(request.allowed).filter((q) => answers[q]).map((q) => [q, answers[q]!]));
+		return { choices, rejected: {}, elapsedMs: 5 };
+	};
+}
+const ctx = {} as never;
+
+describe("Jev subagent routing", () => {
+	it("routes an agentless task, offering only enabled native agents inside the ceiling", async () => {
+		const asked: Asked[] = [];
+		const result = await routeSubagentLaunch(
+			{ task: "fix the bug", agents, ceiling: { allowedAgents: ["delegate", "worker", "secret"], sources: ["test"] } as never },
+			ctx, settings, fakeAsk({ agent: { choice: "worker", confidence: 0.9 } }, asked) as never,
+		);
+		assert.equal(result.agent, "worker");
+		assert.deepEqual(asked[0]!.allowed.agent, ["delegate", "worker"]);
+	});
+
+	it("offers keep for a generic agent and never re-routes an explicit specialist", async () => {
+		const asked: Asked[] = [];
+		const kept = await routeSubagentLaunch({ task: "t", agent: "delegate", agents }, ctx, settings, fakeAsk({ agent: { choice: "keep", confidence: 0.9 } }, asked) as never);
+		assert.equal(kept.agent, "delegate");
+		assert.ok(asked[0]!.allowed.agent!.includes("keep"));
+		assert.ok(!asked[0]!.allowed.agent!.includes("delegate"));
+
+		const explicitAsked: Asked[] = [];
+		const explicit = await routeSubagentLaunch({ task: "t", agent: "reviewer", model: "x/y", agents }, ctx, settings, fakeAsk({}, explicitAsked) as never);
+		assert.equal(explicit.agent, "reviewer");
+		assert.ok(explicitAsked.every((ask) => !("agent" in ask.allowed)));
+	});
+
+	it("abstention leaves the launch as requested", async () => {
+		const result = await routeSubagentLaunch({ task: "t", agents }, ctx, settings, (async () => ({ choices: {}, rejected: { agent: "no-credential" }, failure: "no-credential", elapsedMs: 0 })) as never);
+		assert.equal(result.agent, undefined);
+		assert.equal(result.agents, agents);
+		assert.equal(result.abstained, "no-credential");
+	});
+
+	it("only drops declared, unprotected tools on a confident unneeded, and applies the tier model", async () => {
+		const asked: Asked[] = [];
+		const result = await routeSubagentLaunch(
+			{ task: "summarize the README", agent: "worker", agents },
+			ctx, settings,
+			fakeAsk({ tier: { choice: "simple", confidence: 0.8 }, tool_0: { choice: "unneeded", confidence: 0.9 }, tool_1: { choice: "unneeded" }, tool_2: { choice: "needed", confidence: 0.9 } }, asked) as never,
+		);
+		// read is never offered: tool_0..2 are bash, edit, write.
+		assert.deepEqual(Object.keys(asked[0]!.allowed).sort(), ["tier", "tool_0", "tool_1", "tool_2"]);
+		assert.deepEqual(asked[0]!.allowed.tier, ["simple", "reasoning"]);
+		assert.deepEqual(result.droppedTools, ["bash"]);
+		const worker = result.agents.find((a) => a.name === "worker")!;
+		assert.deepEqual(worker.excludeTools, ["bash"]);
+		assert.equal(worker.model, "p/small");
+		assert.equal(worker.modelProvider, undefined);
+		assert.deepEqual(worker.tools, ["read", "bash", "edit", "write"]);
+		// The discovered list itself is untouched.
+		assert.equal(agents.find((a) => a.name === "worker")!.model, "anthropic/opus");
+	});
+
+	it("skips the tier question when the parent chose a model", async () => {
+		const asked: Asked[] = [];
+		const result = await routeSubagentLaunch({ task: "t", agent: "worker", model: "x/y", agents }, ctx, settings, fakeAsk({ tier: { choice: "simple", confidence: 0.9 } }, asked) as never);
+		assert.ok(!("tier" in asked[0]!.allowed));
+		assert.equal(result.tier, undefined);
+	});
+
+	it("reads settings: off by default, tiers and generic agents when enabled", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "jev-subagent-"));
+		try {
+			const file = path.join(dir, "settings.json");
+			fs.writeFileSync(file, JSON.stringify({ jevAdvisory: { routes: {} } }));
+			assert.equal(readSubagentRoutingSettings(file), undefined);
+			fs.writeFileSync(file, JSON.stringify({ jevAdvisory: { routes: { subagent: { enabled: true, tiers: { simple: " p/s ", bogus: "x" }, genericAgents: ["delegate", "general"] } } } }));
+			const read = readSubagentRoutingSettings(file)!;
+			assert.deepEqual(read.tiers, { simple: "p/s" });
+			assert.deepEqual(read.genericAgents, ["delegate", "general"]);
+			assert.equal(read.connection.timeoutMs, 5000);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -19,6 +19,8 @@ describe("public subagent execution normalization", () => {
 				output: true,
 			},
 		});
+		// Agentless tasks are left for Jev subagent routing; the executor rejects them when it cannot choose.
+		assert.deepEqual(normalizePublicSubagentExecution({ task: "work" }), { ok: true, params: { task: "work", output: true } });
 		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker" }), {
 			ok: true,
 			params: {
@@ -171,7 +173,7 @@ describe("public subagent execution normalization", () => {
 			{ action: "reject-checkpoint", id: "run" },
 			{ agent: "" },
 			{ agent: 42 },
-			{ task: "work" },
+			{ task: " " },
 			{ agent: "worker", task: 42 },
 			{ agent: "worker", workflowScript: "return 1" },
 			{ action: "status", task: "work" },

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' +