@selesai/code 0.13.33 → 0.13.35

package/dist/extensions/package.json

@@ -19,6 +19,7 @@
 			"./herdr-agent-state.ts",
 			"./inline-skills.ts",
 			"./jev-advisory-routing.ts",
+			"./jev-ask-tool.ts",
 			"./rtk.ts",
 			"./tokenin-onboarding.ts",
 			"./pi-graft",

package/dist/extensions/pi-hermes-memory/README.md

@@ -483,45 +483,19 @@ Move behavior:
 
 ## Configuration
 
-Create `~/.selesai/agent/hermes-memory-config.json`:
+Set extension options under `hermesMemory` in `~/.selesai/agent/settings.json`:
 
 ```json
 {
-  "memoryMode": "policy-only",
-  "memoryPolicyStyle": "full",
-  "memoryCharLimit": 5000,
-  "userCharLimit": 5000,
-  "projectCharLimit": 5000,
-  "memoryDir": "~/.selesai/agent/pi-hermes-memory",
-  "projectsMemoryDir": "projects-memory",
-  "sessionSearch": { "variant": "legacy" },
-  "sessionRetentionDays": 0,
-  "quickCheckOnOpen": true,
-  "llmModelOverride": "openrouter/deepseek/deepseek-v4-flash",
-  "llmThinkingOverride": "off",
-  "childExtensionPaths": ["~/.selesai/agent/git/github.com/example/custom-provider-extension/index.ts"],
-  "nudgeInterval": 10,
-  "nudgeToolCalls": 15,
-  "reviewRecentMessages": 0,
-  "reviewEnabled": true,
-  "reviewTransport": "direct",
-  "memoryOverflowStrategy": "auto-consolidate",
-  "autoConsolidate": true,
-  "correctionDetection": true,
-  "failureInjectionEnabled": true,
-  "failureInjectionMaxAgeDays": 7,
-  "failureInjectionMaxEntries": 5,
-  "consolidationTimeoutMs": 180000,
-  "overflowGraceMs": 180000,
-  "autoConsolidationWarnOnFailure": true,
-  "flushOnCompact": true,
-  "flushOnShutdown": true,
-  "flushMinTurns": 6,
-  "flushRecentMessages": 0,
-  "standingInstructionsEnabled": true
+  "hermesMemory": {
+    "llmThinkingOverride": "off",
+    "consolidationTimeoutMs": 300000
+  }
 }
 ```
 
+The extension reads these options at startup. Values in `settings.json` override the legacy `hermes-memory-config.json`, which remains a fallback for existing installations. All settings below are keys inside `hermesMemory`. `llmModelOverride` is optional and uses `provider/model` format (for example, `tokenin/deepseek-v4.1-flash` if your account has access); leave it unset to use the active model.
+
 | Setting | Default | Description |
 |---|---|---|
 | `memoryMode` | `policy-only` | Prompt behavior: `policy-only` injects only memory policy; `legacy-inject` restores full memory prompt injection |
@@ -536,7 +510,7 @@ Create `~/.selesai/agent/hermes-memory-config.json`:
 | `sessionSearch` | `{ "variant": "legacy" }` | Session search implementation: `legacy` keeps the existing SQLite/FTS snippet search; `anchors` uses the opt-in Markdown request surface and returns compact JSONL line-range anchors from `~/.selesai/agent/sessions/` |
 | `sessionRetentionDays` | `0` | Opt-in SQLite session retention, in days. `0` (default) disables pruning entirely and keeps the legacy count-only backfill preflight. When positive, sessions whose JSONL source file was last modified longer ago than the window are pruned from SQLite at startup — **rows only; the JSONL files in `~/.selesai/agent/sessions/` are never deleted** — and both the deferred backfill and `/memory-index-sessions` skip files outside the window, so pruned sessions stay pruned instead of being re-indexed |
 | `quickCheckOnOpen` | `true` | Run a full SQLite integrity check asynchronously after opening the database; set to `false` to skip the startup scan (operation-time recovery remains enabled) |
-| `llmModelOverride` | unset | Optional model override for background review (direct and subprocess), correction save, session flush, and consolidation |
+| `llmModelOverride` | unset | Optional `provider/model` override for background review (direct and subprocess), correction save, session flush, and consolidation; unset uses the active model |
 | `llmThinkingOverride` | unset | Optional thinking override for those LLM calls; valid values are `off`, `minimal`, `low`, `medium`, `high`, and `xhigh`. If `llmModelOverride` is set and this is omitted, review/child calls default to `off` |
 | `childExtensionPaths` | unset | Trusted provider/auth extension sources explicitly allowed in isolated child Pi processes. Values are passed to Pi's standard `-e` resolver, so absolute paths, `~/...`, paths relative to the child working directory, and `git:`/`npm:` package sources are supported. Sibling packages matching the `*-oauth-adapter`/`*-auth-adapter` naming convention (including scoped packages, via their `package.json` `pi.extensions` manifest) are detected automatically. This setting is only needed for custom providers or adapters that are not detected. In-process direct transport (the default for review/flush/correction/consolidation) doesn't need it, since it reads whatever provider auth is already registered. |
 | `nudgeInterval` | `10` | Turns between auto-reviews |
@@ -546,7 +520,7 @@ Create `~/.selesai/agent/hermes-memory-config.json`:
 | `reviewTransport` | `direct` | LLM transport for background review, session flush, correction save, and manual consolidation: `direct` uses in-process `completeSimple()` with subprocess fallback; `subprocess` forces legacy `pi -p` only |
 | `memoryOverflowStrategy` | `auto-consolidate` | Legacy-inject behavior when a Markdown memory file reaches its character limit: `auto-consolidate` runs the existing consolidation flow; `reject` returns an error; `fifo-evict` rotates older entries in file order until the new entry fits |
 | `autoConsolidate` | `true` | Legacy alias for `memoryOverflowStrategy` when `memoryOverflowStrategy` is not set (`true` = `auto-consolidate`, `false` = `reject`) |
-| `consolidationTimeoutMs` | `180000` | Maximum time in milliseconds for a consolidation run (auto and `/memory-consolidate` alike). Configured values are used verbatim; a consolidation pays child-process boot plus a full LLM turn, so values below the default are frequently killed mid-run and log a warning at startup |
+| `consolidationTimeoutMs` | `300000` | Maximum time in milliseconds for a consolidation run (auto and `/memory-consolidate` alike). Configured values are used verbatim; a consolidation pays child-process boot plus a full LLM turn, so values below the default are frequently killed mid-run and log a warning at startup |
 | `overflowGraceMs` | `180000` | Wall-clock grace period after a memory overflow before automatic consolidation is retried; this gives the active agent time to consolidate manually. Set to `0` to disable the grace period |
 | `autoConsolidationWarnOnFailure` | `true` | Log failed automatic consolidation attempts to the session console. Set to `false` to suppress only this warning; the memory tool result still reports the failure reason |
 | `correctionDetection` | `true` | Detect user corrections and save immediately |
@@ -602,7 +576,8 @@ The deferred backfill, live-index, and integrity-check spans may appear after st
 │   │           └── SKILL.md
 │   └── another-project/
 │       └── MEMORY.md
-├── hermes-memory-config.json
+├── settings.json          ← Global settings; extension options are under hermesMemory
+├── hermes-memory-config.json ← Legacy fallback for older extension builds
 └── ...
 ```
 

package/dist/extensions/pi-hermes-memory/src/config.ts

@@ -75,13 +75,42 @@ export const DEFAULT_CONFIG_PATH = path.join(
   AGENT_ROOT,
   "hermes-memory-config.json",
 );
+export const DEFAULT_SETTINGS_PATH = path.join(AGENT_ROOT, "settings.json");
+export const HERMES_MEMORY_SETTINGS_KEY = "hermesMemory";
 
-export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
+function readConfigObject(configPath: string | undefined): Record<string, unknown> | undefined {
+  if (!configPath) return undefined;
   try {
-    if (fs.existsSync(configPath)) {
-      const raw = fs.readFileSync(configPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      // Merge: override defaults with user config
+    const parsed: unknown = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Read extension settings from settings.json, falling back to the legacy file. */
+export function loadConfig(
+  configPath = DEFAULT_CONFIG_PATH,
+  settingsPath?: string,
+): MemoryConfig {
+  try {
+    const legacyConfig = readConfigObject(configPath);
+    const resolvedSettingsPath = settingsPath
+      ?? (configPath === DEFAULT_CONFIG_PATH ? DEFAULT_SETTINGS_PATH : undefined);
+    const settings = readConfigObject(resolvedSettingsPath);
+    const extensionSettings = settings?.[HERMES_MEMORY_SETTINGS_KEY];
+    if (legacyConfig || isRecord(extensionSettings)) {
+      const parsed: Record<string, unknown> = {
+        ...(legacyConfig ?? {}),
+        ...(isRecord(extensionSettings) ? extensionSettings : {}),
+      };
+      // New settings.json values take precedence over the legacy file.
       const config: MemoryConfig = { ...DEFAULT_CONFIG };
       const isNonNegativeNumber = (value: unknown): value is number => (
         typeof value === "number" && Number.isFinite(value) && value >= 0
@@ -156,8 +185,7 @@ export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
         if (normalizedProjectsMemoryDir) config.projectsMemoryDir = normalizedProjectsMemoryDir;
       }
       if (
-        typeof parsed.sessionSearch === "object" &&
-        parsed.sessionSearch !== null &&
+        isRecord(parsed.sessionSearch) &&
         isSessionSearchVariant(parsed.sessionSearch.variant)
       ) {
         config.sessionSearch = { variant: parsed.sessionSearch.variant };
@@ -204,7 +232,7 @@ export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
       return config;
     }
   } catch {
-    // Fall back to defaults on parse error or access issues
+    // Fall back to defaults on unexpected parse or access issues.
   }
   return { ...DEFAULT_CONFIG };
 }

package/dist/extensions/pi-hermes-memory/src/constants.ts

@@ -29,12 +29,12 @@ export const DEFAULT_NUDGE_TOOL_CALLS = 15;
 export const DEFAULT_REVIEW_RECENT_MESSAGES = 0;
 export const DEFAULT_FLUSH_RECENT_MESSAGES = 0;
 /**
- * A consolidation run pays child-process boot plus a full LLM turn, which
- * routinely exceeds 60s — at the old 60s default the auto path was killed
- * mid-run on every attempt (#136). Configured values are honored verbatim,
- * including lower ones; `loadConfig` warns when a value below this is set.
+ * A consolidation run pays child-process boot plus a full LLM turn. Five
+ * minutes leaves room for slower models and larger memory stores. Configured
+ * values are honored verbatim, including lower ones; `loadConfig` warns when a
+ * value below this is set.
  */
-export const DEFAULT_CONSOLIDATION_TIMEOUT_MS = 180000;
+export const DEFAULT_CONSOLIDATION_TIMEOUT_MS = 300000;
 /** Wall-clock grace after overflow before an automatic consolidation may run. */
 export const DEFAULT_OVERFLOW_GRACE_MS = 180000;
 export const DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS = 7;

package/dist/extensions/pi-hermes-memory/src/handlers/auto-consolidate.ts

@@ -337,64 +337,78 @@ export function registerConsolidateCommand(
         });
       }
 
-      try {
-        ctx.ui.notify(
-          `🔄 Starting memory consolidation for ${targets.length} target${targets.length === 1 ? "" : "s"}...`,
-          "info",
-        );
-      } catch {
-        // Best-effort only. If the command context is already stale, continue
-        // with the consolidation work rather than failing before it starts.
-      }
-
-      for (const item of targets) {
-        const entries = entriesForTarget(item.store, item.target);
-
-        if (entries.length === 0) {
-          results.push(`${item.label}: (empty, nothing to consolidate)`);
-          continue;
+      const setStatus = (text?: string) => {
+        try {
+          ctx.ui.setStatus("pi-hermes-memory:consolidation", text);
+        } catch {
+          // Best-effort progress feedback only.
         }
+      };
 
+      setStatus("Preparing memory consolidation…");
+      try {
         try {
           ctx.ui.notify(
-            `⏳ Consolidating ${item.label}...`,
+            `🔄 Starting memory consolidation for ${targets.length} target${targets.length === 1 ? "" : "s"}...`,
             "info",
           );
         } catch {
-          // Best-effort progress feedback only.
+          // Best-effort only. If the command context is already stale, continue
+          // with the consolidation work rather than failing before it starts.
         }
 
-        const result = await triggerConsolidation(
-          pi,
-          item.store,
-          item.target,
-          ctx.signal,
-          timeoutMs,
-          item.toolTarget,
-          llmConfig,
-          ctx,
-          dbManager,
-          activeProjectName,
-          deps,
-        );
-
-        if (result.consolidated) {
-          await item.store.loadFromDisk();
-          results.push(`${item.label}: ✅ consolidated`);
-        } else {
-          results.push(`${item.label}: ❌ ${result.error}`);
+        for (const [index, item] of targets.entries()) {
+          const entries = entriesForTarget(item.store, item.target);
+
+          if (entries.length === 0) {
+            results.push(`${item.label}: (empty, nothing to consolidate)`);
+            continue;
+          }
+
+          setStatus(`Consolidating ${item.label} (${index + 1}/${targets.length})…`);
+          try {
+            ctx.ui.notify(
+              `⏳ Consolidating ${item.label}...`,
+              "info",
+            );
+          } catch {
+            // Best-effort progress feedback only.
+          }
+
+          const result = await triggerConsolidation(
+            pi,
+            item.store,
+            item.target,
+            ctx.signal,
+            timeoutMs,
+            item.toolTarget,
+            llmConfig,
+            ctx,
+            dbManager,
+            activeProjectName,
+            deps,
+          );
+
+          if (result.consolidated) {
+            await item.store.loadFromDisk();
+            results.push(`${item.label}: ✅ consolidated`);
+          } else {
+            results.push(`${item.label}: ❌ ${result.error}`);
+          }
         }
-      }
 
-      const summary = `\n  🔄 Memory Consolidation\n  ${"─".repeat(30)}\n${results.map((r) => `  ${r}`).join("\n")}`;
+        const summary = `\n  🔄 Memory Consolidation\n  ${"─".repeat(30)}\n${results.map((r) => `  ${r}`).join("\n")}`;
 
-      try {
-        ctx.ui.notify(summary, "info");
-      } catch {
-        // Child consolidation can indirectly trigger a runtime reload/session
-        // replacement. If that happens, the original command ctx is stale by
-        // the time we reach the final summary, so the command should exit
-        // quietly instead of surfacing a stale-ctx error.
+        try {
+          ctx.ui.notify(summary, "info");
+        } catch {
+          // Child consolidation can indirectly trigger a runtime reload/session
+          // replacement. If that happens, the original command ctx is stale by
+          // the time we reach the final summary, so the command should exit
+          // quietly instead of surfacing a stale-ctx error.
+        }
+      } finally {
+        setStatus(undefined);
       }
     },
   });

package/dist/extensions/pi-hermes-memory/tests/config.test.ts

@@ -7,9 +7,11 @@ import { loadConfig } from "../src/config.js";
 import { AGENT_ROOT } from "../src/paths.js";
 
 const TEST_CONFIG_PATH = path.join(os.tmpdir(), `hermes-memory-config-test-${process.pid}.json`);
+const TEST_SETTINGS_PATH = path.join(os.tmpdir(), `hermes-settings-test-${process.pid}.json`);
 
 afterEach(() => {
   fs.rmSync(TEST_CONFIG_PATH, { force: true });
+  fs.rmSync(TEST_SETTINGS_PATH, { force: true });
 });
 
 describe("loadConfig", () => {
@@ -30,7 +32,7 @@ describe("loadConfig", () => {
     assert.strictEqual(config.flushRecentMessages, 0);
     assert.strictEqual(config.memoryOverflowStrategy, "auto-consolidate");
     assert.strictEqual(config.autoConsolidate, true);
-    assert.strictEqual(config.consolidationTimeoutMs, 180000);
+    assert.strictEqual(config.consolidationTimeoutMs, 300000);
     assert.strictEqual(config.overflowGraceMs, 180000);
     assert.strictEqual(config.autoConsolidationWarnOnFailure, true);
     assert.strictEqual(config.failureInjectionEnabled, true);
@@ -65,7 +67,7 @@ describe("loadConfig", () => {
         "a lower configured value must be honored, not clamped",
       );
       assert.strictEqual(warnings.length, 1, "a sub-default value should warn once");
-      assert.match(warnings[0], /60000ms.*below the 180000ms default/);
+      assert.match(warnings[0], /60000ms.*below the 300000ms default/);
     } finally {
       console.warn = originalWarn;
     }
@@ -112,6 +114,28 @@ describe("loadConfig", () => {
     assert.strictEqual(config.reviewEnabled, true);
   });
 
+  it("loads hermesMemory from settings.json with precedence over the legacy config", () => {
+    fs.mkdirSync(path.dirname(TEST_CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(TEST_CONFIG_PATH, JSON.stringify({
+      llmThinkingOverride: "high",
+      consolidationTimeoutMs: 240000,
+    }));
+    fs.writeFileSync(TEST_SETTINGS_PATH, JSON.stringify({
+      theme: "dark",
+      hermesMemory: {
+        llmThinkingOverride: "off",
+        llmModelOverride: " tokenin/deepseek-v4.1-flash ",
+        consolidationTimeoutMs: 300000,
+      },
+    }));
+
+    const config = loadConfig(TEST_CONFIG_PATH, TEST_SETTINGS_PATH);
+    assert.strictEqual(config.llmThinkingOverride, "off");
+    assert.strictEqual(config.llmModelOverride, "tokenin/deepseek-v4.1-flash");
+    assert.strictEqual(config.consolidationTimeoutMs, 300000);
+    assert.strictEqual(config.memoryMode, "policy-only");
+  });
+
   it("only accepts boolean quickCheckOnOpen overrides", () => {
     fs.mkdirSync(path.dirname(TEST_CONFIG_PATH), { recursive: true });
     fs.writeFileSync(TEST_CONFIG_PATH, JSON.stringify({ quickCheckOnOpen: "false" }));

package/dist/extensions/pi-hermes-memory/tests/handlers/auto-consolidate.test.ts

@@ -631,6 +631,7 @@ describe("registerConsolidateCommand", () => {
   it("includes project memory when a project store is available", async () => {
     let handler: any;
     const notifications: string[] = [];
+    const statuses: Array<[string, string | undefined]> = [];
     let projectReloaded = false;
 
     const pi = {
@@ -655,7 +656,10 @@ describe("registerConsolidateCommand", () => {
     registerConsolidateCommand(pi, mockStore, 60000, projectStore, "demo-project");
     await handler({}, {
       signal: undefined,
-      ui: { notify: (message: string) => { notifications.push(message); } },
+      ui: {
+        notify: (message: string) => { notifications.push(message); },
+        setStatus: (key: string, text: string | undefined) => { statuses.push([key, text]); },
+      },
     });
 
     assert.strictEqual(execCalls.length, 4, "should consolidate memory, user, failure, and project stores");
@@ -670,6 +674,8 @@ describe("registerConsolidateCommand", () => {
     assert.ok(projectReloaded, "project store should reload after consolidation");
     assert.ok(notifications.some((message) => message.includes("Starting memory consolidation")), "should show an initial progress notification");
     assert.ok(notifications.some((message) => message.includes("⏳ Consolidating memory")), "should show per-target progress");
+    assert.ok(statuses.some(([key, text]) => key === "pi-hermes-memory:consolidation" && text?.includes("Consolidating memory")), "should publish busy progress");
+    assert.deepStrictEqual(statuses.at(-1), ["pi-hermes-memory:consolidation", undefined], "should clear busy progress when done");
     const finalNotification = notifications[notifications.length - 1] ?? "";
     assert.ok(finalNotification.includes("failure: ✅ consolidated"), "final notification should include failure result");
     assert.ok(finalNotification.includes("project:demo-project: ✅ consolidated"), "final notification should include project result");

package/dist/extensions/pi-intercom/index.ts

@@ -1186,7 +1186,11 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     const deliveredEntry = { ...entry, message: injectedMessage, replyCommand };
     replyTracker.queueTurnContext({ from: entry.from, message: injectedMessage, receivedAt: Date.now() });
     const senderDisplay = entry.from.name || entry.from.id.slice(0, 8);
-    const replyInstruction = replyCommand ? `\n\nTo reply, use the intercom tool: ${replyCommand}` : "";
+    // The tool may be an inactive optional capability: say how to activate it, not just its call.
+    const activateHint = pi.getActiveTools().includes("intercom")
+      ? ""
+      : ' (not active yet: call capability_discover with name "intercom" first)';
+    const replyInstruction = replyCommand ? `\n\nTo reply, use the intercom tool${activateHint}: ${replyCommand}` : "";
     const deliveryMetadata = formatInboundDeliveryMetadata(injectedMessage);
     pi.sendMessage(
       {

package/dist/extensions/pi-subagents/src/extension/public-execution.ts

@@ -201,17 +201,19 @@ export function normalizePublicSubagentExecution<T extends PublicSubagentExecuti
 		return { ok: false, error: "Structured single-child execution cannot be combined with workflow, workflowScript, or workflowScriptPath.", mode: "workflow" };
 	}
 	if (params.agent !== undefined || params.task !== undefined) {
-		if (typeof params.agent !== "string" || !params.agent.trim()) {
-			return { ok: false, error: "Structured single-child execution requires agent to be a non-empty string.", mode: "workflow" };
-		}
 		if (params.task !== undefined && typeof params.task !== "string") {
 			return { ok: false, error: "Structured single-child task must be a string when provided.", mode: "workflow" };
 		}
+		// A task without an agent is left for Jev subagent routing; the executor rejects it when routing cannot choose.
+		const agentless = params.agent === undefined && typeof params.task === "string" && params.task.trim() !== "";
+		if (!agentless && (typeof params.agent !== "string" || !params.agent.trim())) {
+			return { ok: false, error: "Structured single-child execution requires agent to be a non-empty string.", mode: "workflow" };
+		}
 		return {
 			ok: true,
 			params: {
 				...params,
-				agent: params.agent.trim(),
+				...(typeof params.agent === "string" ? { agent: params.agent.trim() } : {}),
 				output: params.output === undefined ? true : params.output,
 			} as T,
 		};

package/dist/extensions/pi-subagents/src/extension/schemas.ts

@@ -281,7 +281,7 @@ const ControlOverrides = Type.Object({
 
 const SubagentParamProperties = {
 	agent: Type.Optional(Type.String({ description: "Agent for one-child execution, or target for agent management actions." })),
-	task: Type.Optional(Type.String({ description: "Optional one-child task. Requires agent; cannot combine with action, workflowScript, or workflowScriptPath." })),
+	task: Type.Optional(Type.String({ description: "Optional one-child task. Requires agent unless Jev subagent routing is enabled, in which case agent may be omitted to let Jev choose by function; cannot combine with action, workflowScript, or workflowScriptPath." })),
 	extensionBindings: Type.Optional(Type.Unsafe({ type: "object", maxProperties: 16, additionalProperties: true, description: "Namespaced, bounded plain-JSON metadata delivered only to the child runtime. Namespace keys use package.name/1 syntax." })),
 	// Management action (when present, tool operates in management mode)
 	action: Type.Optional(Type.String({ minLength: 1,

package/dist/extensions/pi-subagents/src/runs/foreground/subagent-executor.ts

@@ -66,6 +66,7 @@ import { retainLiveForegroundNestedRoute } from "../../integrations/pi-web-sessi
 import { validateToolBudgetConfig } from "../shared/tool-budget.ts";
 import { usageBudgetExceededMessage, usageBudgetState, validateUsageBudgetConfig } from "../shared/usage-budget.ts";
 import { intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling, type ResolvedSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
+import { describeSubagentRouting, emitSubagentRoutingTelemetry, readSubagentRoutingSettings, routeSubagentLaunch, warnJevUnavailableOnce } from "../shared/jev-subagent-routing.ts";
 import { isAgentContract } from "../shared/agent-contract.ts";
 import { normalizeExtensionBindings, type ExtensionBindings } from "../shared/extension-bindings.ts";
 import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeSingleOutputOverride, outputPathMappingFromTask, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
@@ -6637,11 +6638,35 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		if (cwdError) return buildRequestedModeError(effectiveParams, cwdError);
 		const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
 		const discovered = deps.discoverAgents(effectiveCwd, scope, requestParentModel?.provider);
-		const discoveredAgents = discovered.agents;
+		let discoveredAgents = discovered.agents;
 		const unknownAgentDiagnosticContext = diagnosticContextFromDiscovery(discovered, effectiveCwd, scope);
 		const canonicalParams = canonicalizeExecutionParams(effectiveParams, discoveredAgents, discovered.agentDiagnostics, unknownAgentDiagnosticContext);
 		if (canonicalParams.error) return buildRequestedModeError(effectiveParams, canonicalParams.error);
 		effectiveParams = canonicalParams.params!;
+		// Jev fills in what a public single-child call left open (agent, tools, model tier); opt-in.
+		const routedSingle = publicExecution && !effectiveParams.chain?.length && !effectiveParams.tasks?.length && typeof effectiveParams.task === "string" && effectiveParams.task.trim() !== "";
+		const jevRouting = routedSingle ? readSubagentRoutingSettings() : undefined;
+		if (jevRouting) {
+			const routed = await routeSubagentLaunch({
+				task: effectiveParams.task!,
+				agent: effectiveParams.agent,
+				model: effectiveParams.model,
+				agents: discoveredAgents,
+				ceiling: intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(resolveCurrentSessionId(ctx.sessionManager))),
+			// pi-subagents' ModelRegistry typings predate `complete`; the host registry has it, and a missing one is an abstention.
+			}, ctx as unknown as Parameters<typeof routeSubagentLaunch>[1], jevRouting);
+			emitSubagentRoutingTelemetry(deps.pi.events, routed);
+			if (routed.abstained === "no-credential" && ctx.hasUI) warnJevUnavailableOnce(ctx.ui, jevRouting.connection.provider);
+			discoveredAgents = routed.agents;
+			if (routed.agent !== undefined) effectiveParams = { ...effectiveParams, agent: routed.agent };
+			const summary = describeSubagentRouting(routed, jevRouting.tiers);
+			if (summary && ctx.hasUI) ctx.ui.notify(summary, "info");
+		}
+		if (routedSingle && !effectiveParams.agent) {
+			return buildRequestedModeError(effectiveParams, jevRouting
+				? "Jev could not choose an agent for this task. Name one: call subagent with { action: \"list\", capabilities: true } to see them."
+				: "Structured single-child execution requires agent; Jev subagent routing (jevAdvisory.routes.subagent.enabled) is off. Name an agent.");
+		}
 		if (effectiveParams.worktree === undefined && deps.config.worktree !== undefined) {
 			effectiveParams = { ...effectiveParams, worktree: deps.config.worktree };
 		}