@selesai/code 0.13.34 → 0.13.37

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 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
+- **`jev_find` finds files by what they do.** ripgrep gathers up to 48 candidate files (matching `pattern`, or listed under `path`/`glob` and ranked by question words), Jev judges each file's best-matching lines against a plain-words `question` in parallel batches of 16, and the agent gets ranked `path:lines (relevance)` pointers instead of file contents. It respects `.gitignore`, stays inside the working directory, skips secret-named files, and returns the unranked candidates when Jev is unavailable. It ships with `ask_jev` under `jevAdvisory.routes.ask`, stays active under the capability gateway, and leaves the loadout while Jev has no credential.
+- **Jev can set up a subagent launch (opt-in).** With `jevAdvisory.routes.subagent.enabled`, Jev fills only what the parent left open on a single-child `subagent` call: it picks an agent by function when `agent` is omitted or generic (`genericAgents`, default `["delegate"]`), may drop tools from that agent's declared list (never `read` or supervision tools), and picks a `simple`/`complex`/`reasoning` model from `tiers` when no `model` was passed. Any abstention launches exactly what was asked.
+
+### Changed
+- **The agent reaches for Jev when locating code.** The `jev_find` guidance tells the agent to use it before grep, find, or reading candidate files when it searches by behavior rather than an exact identifier; exact-name lookups still go to grep.
+
 ## [0.13.34] - 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/capability-gateway/index.ts

@@ -73,9 +73,10 @@ export const GATEWAY_TOOLS = new Set(["capability_catalog", "capability_discover
 
 // Graft supplies pre-turn hybrid context and must remain callable for precise
 // follow-ups; making it dormant defeats both paths. `ask_jev` is the agent's own
-// decision surface for Jev, so it is never something the agent must discover.
+// decision surface for Jev (and `jev_find` its file finder), so neither is something the agent must discover.
 const ALWAYS_ACTIVE_EXTENSION_TOOLS = new Set([
 	"ask_jev",
+	"jev_find",
 	"graft_check_freshness",
 	"graft_file_api",
 	"graft_find_all",

package/dist/extensions/jev/decisions.ts

@@ -28,7 +28,7 @@ import type { AssistantMessage, Context, Model } from "@earendil-works/pi-ai";
 // Advisory configuration (one opt-in area, per-route enablement)
 // ---------------------------------------------------------------------------
 
-export const JEV_ROUTE_NAMES = ["memory", "recommendations", "ask"] as const;
+export const JEV_ROUTE_NAMES = ["memory", "recommendations", "ask", "subagent"] as const;
 export type JevRouteName = (typeof JEV_ROUTE_NAMES)[number];
 
 export interface JevRouteConfig {
@@ -83,6 +83,17 @@ export const DEFAULT_JEV_ASK_ROUTE_CONFIG: JevRouteConfig = {
 	payloadBytes: 32 * 1024,
 };
 
+/**
+ * The `subagent` route sets up a public single-child launch (agent, tools, model tier; see
+ * pi-subagents' jev-subagent-routing.ts). Opt-in, and it sits on the launch path, so its
+ * deadline is shorter than the ask route's; its state is the task plus agent descriptions.
+ */
+export const DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG: JevRouteConfig = {
+	...DEFAULT_JEV_ROUTE_CONFIG,
+	timeoutMs: 5_000,
+	payloadBytes: 16 * 1024,
+};
+
 export const DEFAULT_JEV_ADVISORY_CONFIG: JevAdvisoryConfig = {
 	provider: "tokenin",
 	model: "jev-1.13",
@@ -90,6 +101,7 @@ export const DEFAULT_JEV_ADVISORY_CONFIG: JevAdvisoryConfig = {
 		memory: { ...DEFAULT_JEV_ROUTE_CONFIG },
 		recommendations: { ...DEFAULT_JEV_ROUTE_CONFIG },
 		ask: { ...DEFAULT_JEV_ASK_ROUTE_CONFIG },
+		subagent: { ...DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG },
 	},
 };
 
@@ -153,6 +165,7 @@ export function readJevAdvisoryConfig(settingsPath: string): JevAdvisoryConfig {
 			memory: routeOr(routes.memory),
 			recommendations: routeOr(routes.recommendations),
 			ask: routeOr(routes.ask, DEFAULT_JEV_ASK_ROUTE_CONFIG),
+			subagent: routeOr(routes.subagent, DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG),
 		},
 	};
 }

package/dist/extensions/jev-ask-tool.test.ts

@@ -19,6 +19,8 @@ const state = vi.hoisted(() => ({
 
 vi.mock("@selesai/code", () => ({
 	getSettingsPath: () => state.settingsPath,
+	// jev_find runs the real ripgrep on PATH against the temp repo.
+	ensureTool: async () => "rg",
 	// The same local shell backend the bash tool uses, scripted per command.
 	createLocalBashOperations: () => ({
 		exec: async (command: string, _cwd: string, options: { onData: (data: Buffer) => void }) => {
@@ -30,8 +32,8 @@ vi.mock("@selesai/code", () => ({
 	}),
 }));
 
-import jevAskToolExtension, { askPath, MAX_ASK_QUESTIONS } from "./jev-ask-tool.ts";
-import { JEV_ROUTING_EVENT } from "./jev/decisions.ts";
+import jevAskToolExtension, { askPath, FIND_BATCH, fitFindPayload, MAX_ASK_QUESTIONS } from "./jev-ask-tool.ts";
+import { JEV_ROUTING_EVENT, serializeJevRequest } from "./jev/decisions.ts";
 import { jevResponse, providerTemplate } from "./jev/test-support.ts";
 
 const FILE_SENTINEL = "FILE_BODY_MUST_RETURN_TO_JE ONLY";
@@ -89,6 +91,9 @@ interface AskHarness {
 	ask(params: Record<string, unknown>, signal?: AbortSignal): Promise<{ text: string; details: Record<string, unknown> }>;
 	/** The decision request Jev was sent, parsed. */
 	sent(): Record<string, unknown> | undefined;
+	/** Every tool the extension registered, by name. */
+	tools: Record<string, ToolDefinition>;
+	ctx: unknown;
 }
 
 function harness(
@@ -114,10 +119,10 @@ function harness(
 	const hooks: Record<string, (event: unknown, ctx: unknown) => unknown> = {};
 	let credential = options.credential !== false;
 	const complete = vi.fn(async () => jevResponse(answerText({})));
-	let registered: ToolDefinition | undefined;
+	const tools: Record<string, ToolDefinition> = {};
 	jevAskToolExtension({
 		registerTool: (definition: ToolDefinition) => {
-			registered = definition;
+			tools[definition.name] = definition;
 		},
 		on: (event: string, handler: (event: unknown, ctx: unknown) => unknown) => {
 			hooks[event] = handler;
@@ -143,9 +148,11 @@ function harness(
 			complete,
 		},
 	};
-	const tool = registered as ToolDefinition;
+	const tool = tools.ask_jev as ToolDefinition;
 	return {
 		tool,
+		tools,
+		ctx,
 		complete,
 		telemetry,
 		notices,
@@ -412,6 +419,64 @@ describe("missing material", () => {
 	});
 });
 
+describe("jev_find", () => {
+	const find = async (session: AskHarness, params: Record<string, unknown>) => {
+		const result = await session.tools.jev_find.execute("call-f", params, undefined, undefined, session.ctx);
+		return { text: result.content[0]?.text ?? "", details: result.details };
+	};
+
+	beforeAll(() => {
+		writeFileSync(join(repo, "src", "other.ts"), "// mentions round only in passing\nexport const x = 1;\n", "utf-8");
+		writeFileSync(join(repo, ".env"), "round=SECRET_ENV_VALUE\n", "utf-8");
+	});
+
+	it("ranks ripgrep's candidates by Jev relevance and returns pointers, never contents", async () => {
+		const session = harness();
+		// Jev: the file whose question names round.ts is relevant, the rest are not.
+		session.complete.mockImplementation(async (_model: unknown, request: { messages: Array<{ content: string }> }) => {
+			const sent = JSON.parse(request.messages[0].content) as { questions: Record<string, { instructions: { question: string } }> };
+			const answers = Object.fromEntries(
+				Object.entries(sent.questions).map(([name, q]) => [name, { noul: q.instructions.question.includes("round.ts") ? 0.93 : 0.08 }]),
+			);
+			return jevResponse(answerText(answers));
+		});
+		const result = await find(session, { question: "where is rounding implemented", pattern: "round", ignoreCase: true });
+
+		expect(result.text).toMatch(/judged 2 of 2 candidate/);
+		expect(result.text).toContain("- src/round.ts:1 (0.93)");
+		expect(result.text).not.toContain("other.ts");
+		expect(result.text).not.toContain(FILE_SENTINEL);
+		const sent = session.sent() as { state: { files: Record<string, string> } };
+		expect(Object.keys(sent.state.files).sort()).toEqual(["src/other.ts", "src/round.ts"]);
+		expect(sent.state.files["src/round.ts"]).toContain(FILE_SENTINEL);
+		expect(JSON.stringify(sent)).not.toContain("SECRET_ENV_VALUE");
+	});
+
+	it("lists a directory by glob and still returns candidates when Jev is unreachable", async () => {
+		const session = harness({ credential: false });
+		const result = await find(session, { question: "rounding", path: "src", glob: "*.ts" });
+
+		expect(session.complete).not.toHaveBeenCalled();
+		expect(result.text).toMatch(/Jev did not judge \(no-credential\); 2 candidate/);
+		// The question word in the path orders the unjudged listing.
+		expect(result.text.split("\n")[1]).toBe("- src/round.ts");
+	});
+
+	it("shrinks escape-heavy snippets until a full batch fits the request budget", () => {
+		// Quotes and newlines double under JSON escaping, which is what overflowed live.
+		const snippet = '"\n\t\\'.repeat(1_000);
+		const batch = Array.from({ length: FIND_BATCH }, (_, i) => ({ path: `src/f${i}.ts`, lines: [], snippet }));
+		const payload = fitFindPayload("q", batch, 32 * 1024);
+		expect(serializeJevRequest(payload, 32 * 1024)).toBeDefined();
+		expect(Object.keys(payload.questions as object)).toHaveLength(FIND_BATCH);
+	});
+
+	it("refuses a search root outside the working directory", async () => {
+		const result = await find(harness(), { question: "x", path: ".." });
+		expect(result.text).toContain("outside the working directory");
+	});
+});
+
 describe("askPath symlinks", () => {
 	it("refuses links that escape the working directory or point at a secret", () => {
 		const root = mkdtempSync(join(tmpdir(), "ask-path-"));