@selesai/code 0.13.34 → 0.13.37

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/docs/settings.md

@@ -50,7 +50,7 @@ Use `/trust` in interactive mode to save a project trust decision for future ses
 
 The bundled `jev-advisory-routing` extension uses the Jev decisions model for bounded opt-in
 routing. The host-side routes stay off until they are enabled in `jevAdvisory`; the agent's own
-`ask` route is on by default. All three share one Jev provider/model pair:
+`ask` route is on by default. All routes share one Jev provider/model pair:
 
 - `memory` — only after an explicit durable-memory cue (for example “the convention we
   decided” or “don't repeat the past failure”), Jev chooses one read-only local
@@ -67,6 +67,21 @@ routing. The host-side routes stay off until they are enabled in `jevAdvisory`;
   of the agent's loadout before each run (it returns after `/tokenin add`, no reload needed), and a call
   that slips through reads no file and runs no command.
 
+  The same route also offers `jev_find`, a file finder: ripgrep gathers up to 48 candidate files
+  (those matching `pattern`, or every file under `path` filtered by `glob`, ranked by question words),
+  Jev judges each file's best-matching lines against the agent's `question` in parallel batches of 16,
+  and the agent gets ranked `path:lines (relevance)` pointers — never file contents. It respects
+  `.gitignore`, stays inside the working directory, skips secret-named files, and still returns the
+  unranked candidates when Jev is unavailable.
+- `subagent` — sets up a single-child `subagent` call from the parent agent (off by default). Jev only
+  fills what the parent left open, and can only narrow: (1) when `agent` is omitted or generic
+  (`genericAgents`, default `["delegate"]`), it picks an agent by function from enabled native agents
+  inside the capability ceiling; (2) it may drop tools from that agent's declared `tools` for this run
+  (never `read` or supervision tools, and never adds one); (3) when `tiers` is set and the parent
+  passed no `model`, it picks `simple`, `complex`, or `reasoning` and launches that tier's model. Jev
+  sees only the task and agent descriptions. Any abstention launches exactly what was asked; an
+  agentless task that Jev cannot route is rejected with a request to name an agent.
+
 | Setting | Type | Default | Description |
 |---------|------|---------|-------------|
 | `jevAdvisory.provider` | string | `"tokenin"` | Provider serving the Jev decisions deployment |
@@ -74,12 +89,15 @@ routing. The host-side routes stay off until they are enabled in `jevAdvisory`;
 | `jevAdvisory.baseUrl` | string | inherited | Base URL override; defaults to any registered model of `provider` |
 | `jevAdvisory.routes.memory.enabled` | boolean | `false` | Enable the memory-lookup route |
 | `jevAdvisory.routes.recommendations.enabled` | boolean | `false` | Enable skill/workflow and verification recommendations |
-| `jevAdvisory.routes.ask.enabled` | boolean | `true` | Offer the agent the `ask_jev` tool; set `false` to turn it off |
-| `<route>.timeoutMs` | number | `8000` | Route request timeout (ms); memory is capped at 750ms; `ask` defaults to `15000` |
+| `jevAdvisory.routes.ask.enabled` | boolean | `true` | Offer the agent the `ask_jev` and `jev_find` tools; set `false` to turn both off |
+| `jevAdvisory.routes.subagent.enabled` | boolean | `false` | Let Jev choose the agent, tools, and model tier of a subagent call |
+| `jevAdvisory.routes.subagent.tiers` | object | unset | `{ "simple"?, "complex"?, "reasoning"? }` → `provider/id` model; tier routing needs at least two |
+| `jevAdvisory.routes.subagent.genericAgents` | string[] | `["delegate"]` | Agents Jev may replace with a specialist |
+| `<route>.timeoutMs` | number | `8000` | Route request timeout (ms); memory is capped at 750ms; `ask` defaults to `15000`, `subagent` to `5000` |
 | `<route>.minConfidence` | number | `0.6` | Below this Jev confidence the route abstains |
 | `<route>.contextTurns` | number | `4` | Prior user turns sent as recommendation context; memory sends only the current bounded prompt |
 | `<route>.contextChars` | number | `4000` | Character budget for recommendation context |
-| `<route>.payloadBytes` | number | `8192` | Hard cap on the serialized decision request; `ask` defaults to `32768` |
+| `<route>.payloadBytes` | number | `8192` | Hard cap on the serialized decision request; `ask` defaults to `32768`, `subagent` to `16384` |
 
 `ask` ignores `minConfidence`, `contextTurns`, and `contextChars`: it returns every confidence to the
 agent, and its context is whatever the agent put in the request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.34",
+  "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": {