@selesai/code 0.13.35 → 0.13.38

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.38] - 2026-10-01
+
+### Changed
+- **`jev_find` returns source evidence, not just file pointers.** Large trees are narrowed through directory, file, and source-unit judging; results include ranked files, reading leads, and accepted source verbatim with original line numbers, capped at 12 Jev requests and 16 KiB of source per call. JavaScript and TypeScript are split into declarations when the parser is available; other files and installs without it use bounded text chunks.
+
+### Fixed
+- **Jev Find remains useful when Jev cannot judge.** It returns ripgrep-ranked candidates with local keyword-window source, and provider diagnostics expose only a failure category and optional HTTP status, never raw provider error text.
+
+## [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/jev/decisions.test.ts

@@ -17,6 +17,7 @@ const state = vi.hoisted(() => ({ settingsPath: "" }));
 // layer owns the non-streaming decisions request), so a suite stubs that.
 import {
 	askJev,
+	askJevAnswers,
 	buildConversation,
 	buildJevPayload,
 	confidenceBucket,
@@ -278,6 +279,23 @@ describe("askJev", () => {
 		expect(await ask()).toMatchObject({ failure: "malformed" });
 	});
 
+	it("reports safe transport diagnostics without returning raw provider errors", async () => {
+		const error = Object.assign(new Error("secret=must-not-escape"), { status: 503 });
+		completeMock.mockRejectedValue(error);
+
+		const result = await askJevAnswers(runtime() as never, CONNECTION, { payload: {}, maxBytes: 1_024 });
+		expect(result).toMatchObject({ failure: "transport", diagnostic: { kind: "provider-error", httpStatus: 503 } });
+		expect(JSON.stringify(result)).not.toContain("must-not-escape");
+	});
+
+	it("extracts only the HTTP status from TokenIn's error completion", async () => {
+		completeMock.mockResolvedValue(jevResponse("", { stopReason: "error", errorMessage: "HTTP 429: private response body" }));
+
+		const result = await askJevAnswers(runtime() as never, CONNECTION, { payload: {}, maxBytes: 1_024 });
+		expect(result).toMatchObject({ failure: "transport", diagnostic: { kind: "provider-error", httpStatus: 429 } });
+		expect(JSON.stringify(result)).not.toContain("private response body");
+	});
+
 	it("abstains per question on an unlisted, low-confidence, or missing answer", async () => {
 		completeMock.mockResolvedValue(jevResponse(jevAnswers({ repository_context: { choice: "maybe", confidence: 1 } })));
 		expect(await ask()).toMatchObject({ choices: {}, failure: "unknown-choice" });

package/dist/extensions/jev/decisions.ts

@@ -426,10 +426,41 @@ function responseText(response: { content: readonly { type: string; text?: strin
 }
 
 function failureReason(error: unknown): JevAbstainReason {
-	if (isRecord(error) && (error.name === "TimeoutError" || error.name === "AbortError")) return "timeout";
+	try {
+		if (isRecord(error) && (error.name === "TimeoutError" || error.name === "AbortError")) return "timeout";
+	} catch {
+		// A hostile error object is still just a transport failure.
+	}
 	return "transport";
 }
 
+function failureDiagnostic(error: unknown, failure: JevAbstainReason): JevFailureDiagnostic {
+	if (failure === "timeout") return { kind: "timeout" };
+	try {
+		const response = isRecord(error) && isRecord(error.response) ? error.response : undefined;
+		const message =
+			typeof error === "string"
+				? error
+				: error instanceof Error
+					? error.message
+					: isRecord(error) && typeof error.errorMessage === "string"
+						? error.errorMessage
+						: "";
+		const messageStatus = /^HTTP (\d{3}):/.exec(message)?.[1];
+		const httpStatus =
+			(isRecord(error) ? (error.status ?? error.statusCode ?? response?.status) : undefined) ??
+			(messageStatus ? Number(messageStatus) : undefined);
+		return {
+			kind: "provider-error",
+			...(typeof httpStatus === "number" && Number.isInteger(httpStatus) && httpStatus >= 100 && httpStatus <= 599
+				? { httpStatus }
+				: {}),
+		};
+	} catch {
+		return { kind: "provider-error" };
+	}
+}
+
 interface JevAuth {
 	ok: boolean;
 	apiKey?: string;
@@ -494,10 +525,17 @@ export async function askJev(
 	return { choices, rejected, elapsedMs: result.elapsedMs };
 }
 
+/** Safe, content-free context for a failed Jev request. Never contains provider error text. */
+export interface JevFailureDiagnostic {
+	kind: "timeout" | "provider-error" | "malformed-response";
+	httpStatus?: number;
+}
+
 /** Jev's raw `answers` envelope, or why the request produced none. */
 export interface JevAnswers {
 	answers?: Record<string, unknown>;
 	failure?: JevAbstainReason;
+	diagnostic?: JevFailureDiagnostic;
 	elapsedMs: number;
 }
 
@@ -510,7 +548,8 @@ export interface JevAnswers {
  * was asked. Nothing beyond the envelope is validated here, so a caller that
  * expects typed answers owns interpreting them. Every failure — no provider
  * template, no credential, an oversized request, a timeout, a rejected call, or
- * malformed JSON — is an absent decision, and this never throws.
+ * malformed JSON — is an absent decision, and this never throws. Failure diagnostics
+ * contain only a category and optional HTTP status, never provider error text.
  */
 export async function askJevAnswers(
 	ctx: JevRuntime,
@@ -518,7 +557,11 @@ export async function askJevAnswers(
 	request: { payload: unknown; maxBytes: number },
 ): Promise<JevAnswers> {
 	const started = Date.now();
-	const abstained = (failure: JevAbstainReason): JevAnswers => ({ failure, elapsedMs: Date.now() - started });
+	const abstained = (failure: JevAbstainReason, diagnostic?: JevFailureDiagnostic): JevAnswers => ({
+		failure,
+		...(diagnostic ? { diagnostic } : {}),
+		elapsedMs: Date.now() - started,
+	});
 
 	const access = await jevAccess(ctx, connection);
 	if ("failure" in access) return abstained(access.failure);
@@ -539,16 +582,21 @@ export async function askJevAnswers(
 			{ apiKey: auth.apiKey, headers: auth.headers, maxTokens: JEV_MAX_TOKENS, signal },
 		);
 	} catch (error) {
-		return abstained(failureReason(error));
+		const failure = failureReason(error);
+		return abstained(failure, failureDiagnostic(error, failure));
 	}
 	// A provider failure or a deadline arrives as a message with an error stop
 	// reason rather than as a thrown error.
 	if (completion.stopReason === "error" || completion.stopReason === "aborted") {
-		return abstained(signal.aborted ? "timeout" : "transport");
+		const failure = signal.aborted ? "timeout" : "transport";
+		return abstained(
+			failure,
+			failure === "timeout" ? { kind: "timeout" } : failureDiagnostic(completion.errorMessage, failure),
+		);
 	}
 
 	const answers = parseAnswers(responseText(completion));
-	if (!answers) return abstained("malformed");
+	if (!answers) return abstained("malformed", { kind: "malformed-response" });
 	return { answers, elapsedMs: Date.now() - started };
 }