@selesai/code 0.13.35 → 0.13.38

package/dist/extensions/jev-find-source.ts

@@ -0,0 +1,190 @@
+/**
+ * jev-find-source — the source units `jev_find` asks Jev about and returns verbatim.
+ *
+ * A unit is a line range of one file. JavaScript and TypeScript files are split with the
+ * TypeScript parser into top-level statements (consecutive imports merged, and a class or
+ * interface longer than FIND_CHUNK_LINES split into its members, each keeping the header line),
+ * each with the comments directly above it. Every other file, and a script file when the parser
+ * is not installed, is split into blank-line-separated chunks of at most FIND_CHUNK_LINES lines.
+ * Line numbers are 1-based and always the file's own: excerpts are cut from the file, never
+ * reconstructed.
+ */
+import { extname } from "node:path";
+import type * as TypeScript from "typescript";
+
+type TypeScriptApi = typeof TypeScript;
+
+/** ponytail: 40-line chunks for non-script files; raise once Jev is measured on longer units. */
+export const FIND_CHUNK_LINES = 40;
+const UNIT_NAME_CHARS = 40;
+
+export interface SourceUnit {
+	/** What the unit is: a declaration name, `Class.member`, `imports`, or the chunk's first line. */
+	name: string;
+	/** First line, 1-based, inclusive. */
+	start: number;
+	/** Last line, 1-based, inclusive. */
+	end: number;
+	/** Header line of the enclosing class or interface, kept with a member unit. */
+	header?: number;
+}
+
+let typeScript: Promise<TypeScriptApi | undefined> | undefined;
+
+/**
+ * The TypeScript compiler, or undefined when it is not installed: it is a devDependency, so a
+ * published install parses nothing and every file is chunked instead.
+ */
+export function loadTypeScript(): Promise<TypeScriptApi | undefined> {
+	typeScript ??= import("typescript").then(
+		(module: unknown) => {
+			const api = ((module as { default?: TypeScriptApi }).default ?? module) as TypeScriptApi;
+			return typeof api.createSourceFile === "function" ? api : undefined;
+		},
+		() => undefined,
+	);
+	return typeScript;
+}
+
+const SCRIPT_KINDS: Record<string, "TS" | "TSX" | "JS" | "JSX"> = {
+	".ts": "TS",
+	".tsx": "TSX",
+	".js": "JS",
+	".jsx": "JSX",
+	".mjs": "JS",
+	".cjs": "JS",
+};
+
+/** Whether `path` is split with the TypeScript parser (when it is installed). */
+export function isScriptPath(path: string): boolean {
+	return extname(path).toLowerCase() in SCRIPT_KINDS;
+}
+
+/** A file's source units in file order; `ts` undefined chunks every file. */
+export function splitSourceUnits(path: string, text: string, ts: TypeScriptApi | undefined): SourceUnit[] {
+	const kind = SCRIPT_KINDS[extname(path).toLowerCase()];
+	if (ts && kind) {
+		try {
+			const units = scriptUnits(ts, path, text, ts.ScriptKind[kind]);
+			if (units.length > 0) return units;
+		} catch {
+			// A parser crash on odd input falls back to chunks; the file is still readable.
+		}
+	}
+	return chunkUnits(text);
+}
+
+function firstLine(text: string): string {
+	const line = text.split("\n").find((row) => row.trim() !== "") ?? "";
+	return line.trim().slice(0, UNIT_NAME_CHARS);
+}
+
+function scriptUnits(ts: TypeScriptApi, path: string, text: string, kind: TypeScript.ScriptKind): SourceUnit[] {
+	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, kind);
+	const lineOf = (pos: number) => source.getLineAndCharacterOfPosition(pos).line + 1;
+	/**
+	 * A node's first line, counting the comments directly above it: a comment separated by a blank
+	 * line (a section banner) or sitting on the previous node's last line (`a(); // note`) is not its own.
+	 */
+	const startOf = (node: TypeScript.Node, floor: number): number => {
+		let start = lineOf(node.getStart(source));
+		const comments = ts.getLeadingCommentRanges(text, node.pos) ?? [];
+		for (let i = comments.length - 1; i >= 0; i -= 1) {
+			const comment = comments[i];
+			const from = lineOf(comment.pos);
+			if (from <= floor || lineOf(comment.end) < start - 1) break;
+			start = from;
+		}
+		return start;
+	};
+	const nameOf = (node: TypeScript.Node): string => {
+		const named = (node as { name?: TypeScript.Node }).name;
+		if (named) return named.getText(source);
+		if (ts.isVariableStatement(node)) {
+			return node.declarationList.declarations.map((declaration) => declaration.name.getText(source)).join(", ");
+		}
+		if (ts.isConstructorDeclaration(node)) return "constructor";
+		if (ts.isExportAssignment(node)) return "export default";
+		return firstLine(node.getText(source));
+	};
+
+	const units: SourceUnit[] = [];
+	let floor = 0;
+	for (const statement of source.statements) {
+		const start = startOf(statement, floor);
+		const end = lineOf(statement.end);
+		floor = end;
+		if (ts.isImportDeclaration(statement) || ts.isImportEqualsDeclaration(statement)) {
+			const last = units.at(-1);
+			if (last?.name === "imports" && last.end >= start - 1) last.end = end;
+			else units.push({ name: "imports", start, end });
+			continue;
+		}
+		const container =
+			ts.isClassDeclaration(statement) || ts.isInterfaceDeclaration(statement) ? statement : undefined;
+		const members = container?.members;
+		if (container && members && members.length > 0 && end - start + 1 > FIND_CHUNK_LINES) {
+			const owner = nameOf(container);
+			const header = lineOf((container.name ?? container).getStart(source));
+			let memberFloor = header;
+			for (const member of members) {
+				const memberStart = startOf(member, memberFloor);
+				const memberEnd = lineOf(member.end);
+				memberFloor = memberEnd;
+				units.push({
+					name: `${owner}.${nameOf(member)}`,
+					start: memberStart,
+					end: memberEnd,
+					...(memberStart > header ? { header } : {}),
+				});
+			}
+			continue;
+		}
+		units.push({ name: nameOf(statement), start, end });
+	}
+	return units;
+}
+
+/** Blank-line-separated paragraphs packed into chunks of at most FIND_CHUNK_LINES lines. */
+export function chunkUnits(text: string): SourceUnit[] {
+	const rows = text.split("\n");
+	const paragraphs: Array<{ start: number; end: number }> = [];
+	rows.forEach((row, index) => {
+		if (row.trim() === "") return;
+		const last = paragraphs.at(-1);
+		if (last && last.end === index) last.end = index + 1;
+		else paragraphs.push({ start: index + 1, end: index + 1 });
+	});
+	const ranges: Array<{ start: number; end: number }> = [];
+	for (const paragraph of paragraphs) {
+		const current = ranges.at(-1);
+		if (current && paragraph.end - current.start + 1 <= FIND_CHUNK_LINES) {
+			current.end = paragraph.end;
+			continue;
+		}
+		// A paragraph longer than a chunk is cut into chunk-sized pieces.
+		for (let start = paragraph.start; start <= paragraph.end; start += FIND_CHUNK_LINES) {
+			ranges.push({ start, end: Math.min(paragraph.end, start + FIND_CHUNK_LINES - 1) });
+		}
+	}
+	return ranges.map((range) => ({ ...range, name: firstLine(rows[range.start - 1]) }));
+}
+
+/**
+ * Line windows around the best keyword lines (±`context` lines), merged where they overlap: the
+ * source returned when Jev could not judge a file's units. With no keyword line, the file's head.
+ */
+export function keywordWindows(lineCount: number, hits: readonly number[], context = 3, maxWindows = 3): SourceUnit[] {
+	if (lineCount <= 0) return [];
+	const anchors = [...new Set(hits.filter((line) => line >= 1 && line <= lineCount))].slice(0, maxWindows);
+	if (anchors.length === 0) return [{ name: "file head", start: 1, end: Math.min(lineCount, 2 * context + 1) }];
+	const windows: SourceUnit[] = [];
+	for (const line of anchors.sort((a, b) => a - b)) {
+		const start = Math.max(1, line - context);
+		const end = Math.min(lineCount, line + context);
+		const last = windows.at(-1);
+		if (last && start <= last.end + 1) last.end = Math.max(last.end, end);
+		else windows.push({ name: "keyword window", start, end });
+	}
+	return windows;
+}

package/dist/extensions/package.json

@@ -24,9 +24,9 @@
 			"./tokenin-onboarding.ts",
 			"./pi-graft",
 			"./undo.ts",
+			"./pi-web-agent",
 			"./pi-subagents",
 			"./pi-tool-display",
-			"./pi-web-agent",
 			"./pi-hermes-memory",
 			"./tps.ts",
 			"./capability-gateway",

package/dist/extensions/pi-subagents/agents/researcher.md

@@ -1,7 +1,7 @@
 ---
 name: researcher
 description: Autonomous web researcher — searches, evaluates, and synthesizes a focused research brief
-tools: read, write, web_search, fetch_content, get_search_content, source_check
+tools: read, write, web_explore
 thinking: medium
 systemPromptMode: replace
 inheritProjectContext: true
@@ -16,11 +16,10 @@ Given a question or topic, run focused web research and produce a concise, well-
 
 Working rules:
 - Break the problem into 2-4 distinct research angles.
-- Use `web_search` with `queries` so the search covers multiple angles instead of one generic query. Use `workflow: "none"` unless the task explicitly needs the interactive curator.
-- Treat search-result summaries as discovery aids, not final evidence for important claims. Fetch the original source when a claim is important, disputed, surprising, or decision-relevant.
+- Use `web_explore` once per research angle with a focused `query`; it handles search, fetch, and source ranking internally. Call it again with a narrower query to fill gaps.
+- Treat search-result summaries as discovery aids, not final evidence for important claims. Re-check important, disputed, surprising, or decision-relevant claims against the original source with a narrower `web_explore` query.
 - Prefer primary, official, authoritative, or directly relevant sources. Keep a smaller set of strong sources rather than many weak or redundant ones; reject stale, redundant, or SEO-heavy sources, and flag stale evidence when freshness materially affects the answer.
-- Use `source_check` against fetched source content for decision-critical or disputed claims, benchmark/performance claims, pricing/licensing claims, security claims, and wording that could materially affect a recommendation. Do not use it for every trivial fact.
-- `source_check` must be registered by the loaded provider before launch. If a registered `source_check` call fails, continue by fetching and inspecting the original source directly, and disclose the validation limitation rather than failing the research run.
+- Verify decision-critical or disputed claims, benchmark/performance claims, pricing/licensing claims, security claims, and wording that could materially affect a recommendation against the original source. Do not do this for every trivial fact. Disclose any validation limitation rather than failing the research run.
 - Label direct evidence, source interpretation, and researcher inference distinctly. Never present an inference as if the source stated it directly.
 - Record contradictions instead of silently resolving them. Record missing evidence when a claim cannot be verified.
 - Never invent dates, quotations, citations, or unsupported precision.

package/dist/extensions/pi-subagents/docs/agents.md

@@ -73,13 +73,7 @@ Native `oracle` runs inside Pi and can use its configured read tools. The Claude
 | `external-job-requests/` and `external-job-responses/` | Host-mediated provider bridge | pending request, terminal response | Host process writes a matching response and removes the request | Bridge timeout or malformed request response | Requests are operation-scoped. Recovery sends `reattach`/`result`, not `start` or `follow-up`, when job metadata exists. `start` and `follow-up` use durable dispatch claims | Provider not registered, host bridge not loaded, malformed request, provider exception, ambiguous dispatch without a provider job id |
 | Provider artifact path | External provider | provider-defined terminal artifact | Provider returns `artifactPath`, or Pi writes returned text to `external-job-<index>.result.md` | Provider reports failure or no result | Existing artifact path is retained in `status.json` | Missing artifact with no text output returns a terminal message instead of inventing content |
 
-The `researcher` builtin uses `web_search`, `fetch_content`, `get_search_content`, and selective `source_check` validation. Those require [pi-web-access](https://github.com/nicobailon/pi-web-access):
-
-```bash
-pi install npm:pi-web-access
-```
-
-The loaded provider must register all four tools, including `source_check`, before launch; a missing required tool prevents a successful run. Fetched-source inspection is a fallback for a registered `source_check` call failing, not for missing registration.
+The `researcher` builtin uses `web_explore` from the bundled `pi-web-agent` extension. Because the `tools` field is a strict allowlist, `web_explore` must be registered in the child; run `researcher` as a background child (`async: true`) so ambient extensions load.
 
 ## Overriding builtins and custom agents
 

package/dist/extensions/pi-subagents/test/unit/agent-frontmatter.test.ts

@@ -1904,7 +1904,7 @@ Do work
 				delegate: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
 				reviewer: ["read", "grep", "find", "ls", "contact_supervisor"],
 				scout: ["read", "grep", "find", "ls", "bash", "write", "contact_supervisor"],
-				researcher: ["read", "write", "web_search", "fetch_content", "get_search_content", "source_check"],
+				researcher: ["read", "write", "web_explore"],
 			};
 			for (const [name, tools] of Object.entries(expectedTools)) {
 				const agent = agents.find((candidate) => candidate.name === name);
@@ -1914,12 +1914,11 @@ Do work
 
 			const researcherPrompt = agents.find((candidate) => candidate.name === "researcher")?.systemPrompt ?? "";
 			assert.match(researcherPrompt, /search-result summaries as discovery aids, not final evidence/);
-			assert.match(researcherPrompt, /source_check.*decision-critical or disputed claims/);
+			assert.match(researcherPrompt, /Verify decision-critical or disputed claims/);
 			assert.match(researcherPrompt, /direct evidence, source interpretation, and researcher inference distinctly/);
 			assert.match(researcherPrompt, /Record contradictions.*Record missing evidence/);
 			assert.match(researcherPrompt, /Never invent dates, quotations, citations, or unsupported precision/);
-			assert.match(researcherPrompt, /`source_check` must be registered by the loaded provider before launch/);
-			assert.match(researcherPrompt, /If a registered `source_check` call fails, continue/);
+			assert.match(researcherPrompt, /`web_explore`/);
 			assert.match(researcherPrompt, /\*\*Support:\*\* direct evidence \| interpretation\. \*\*Confidence:\*\* high \| medium \| low/);
 		} finally {
 			if (previousHome === undefined) delete process.env.HOME;

package/dist/extensions/pi-web-agent/src/extension.ts

@@ -1,3 +1,4 @@
+import { fileURLToPath } from 'node:url';
 import type { ExtensionAPI } from '@selesai/code';
 import { getDefaultBackendConfig, type BackendConfig } from './backends/config.js';
 import { Type } from 'typebox';
@@ -71,6 +72,16 @@ async function getEffectiveBackendConfig(pi: ExtensionAPI): Promise<BackendConfi
 export default function extension(pi: ExtensionAPI) {
   registerWebAgentConfigCommands(pi);
 
+  // Lets foreground `researcher` children load this extension (see pi-subagents builtin augmentations).
+  pi.events.on('pi-subagents:request-builtin-agent-augmentations', (request: unknown) => {
+    (request as { register?: (a: unknown) => void } | undefined)?.register?.({
+      id: 'pi-web-agent',
+      agentNames: ['researcher'],
+      addTools: ['web_explore'],
+      subagentOnlyExtensions: [fileURLToPath(import.meta.url)]
+    });
+  });
+
   const injectedWebExplore = (pi as ExtensionAPI & { __webExploreTool?: ReturnType<typeof createWebExploreTool> }).__webExploreTool;
   let cachedBackendKey: string | undefined;
   let cachedWebExplore: ReturnType<typeof createWebExploreTool> | undefined;

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 () => {