@a-t-h-i/bot-lobby 0.6.0 → 0.6.2

package/src/master/master.ts

@@ -13,6 +13,8 @@ import { parseWorkerResult, validateWorkerResult } from "../roles/worker.ts";
 import { parseReviewResult, validateReviewResult } from "../roles/reviewer.ts";
 import { truncate } from "../text.ts";
 import { isScoutResultUsable, parseScoutResult, validateScoutResult } from "../roles/scout.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
 
 export interface ScoutOutcome {
   result: ScoutResult;
@@ -36,6 +38,10 @@ export interface ScoutRequest {
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
+  /** Likely files for each scout's context, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Moves a trivial scout to the cheaper model, while the classifier's effort routing is on. */
+  effort?: EffortRouter;
 }
 
 /** Model, thinking and time limit for one run, from settings. */
@@ -53,16 +59,41 @@ function scoutInstruction(request: ScoutRequest, domain: Domain): string {
   ].join("\n");
 }
 
-function scoutContext(request: ScoutRequest, domain: Domain): AgentRequest["context"] {
+function scoutContext(request: ScoutRequest, domain: Domain, likely = ""): AgentRequest["context"] {
   const slices = readAgentKnowledge(request.dataRoots, domain);
   return {
     task: request.taskText,
     ...selectKnowledge(`${request.taskText} ${domainSpec(domain).scoutFocus}`, slices),
     instructions: request.config.agents[domain].instructions,
-    workflowContext: `Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`,
+    workflowContext: [`Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`, likely].filter(Boolean).join("\n\n"),
   };
 }
 
+/** Where the classifier routes a run, or undefined (no router, no route, a failure). */
+async function routeFor(effort: EffortRouter | undefined, instruction: string, profile: { model?: string; thinking: string }, options: { thinkingFixed?: boolean; context?: string; signal?: AbortSignal }): Promise<EffortRoute | undefined> {
+  if (!effort) return undefined;
+  try {
+    return await effort.route(instruction, profile, options);
+  } catch {
+    return undefined;
+  }
+}
+
+/** The run fields a route changes: model, thinking, no in-place retry (the fallback is the retry), and its label. */
+function routedFields(route: EffortRoute): Pick<AgentRequest, "model" | "thinking" | "retries" | "routedFrom" | "route"> {
+  return { model: route.model, thinking: route.thinking, retries: 0, routedFrom: profileLabel(route.from), route: routeLabel(route) };
+}
+
+/** The Likely files block for one agent's step, or "" without hints. */
+async function likelyFor(hints: FileHinter | undefined, query: string, signal: AbortSignal | undefined, context?: string): Promise<string> {
+  if (!hints) return "";
+  try {
+    return await hints.block(query, signal, context);
+  } catch {
+    return "";
+  }
+}
+
 function toOutcome(run: AgentRun, domain: Domain): ScoutOutcome {
   if (run.status !== "success") {
     return {
@@ -78,20 +109,36 @@ function toOutcome(run: AgentRun, domain: Domain): ScoutOutcome {
 
 /** Run the selected domain scouts concurrently and persist their findings. */
 export async function runScouts(request: ScoutRequest, run: ProcessRunner = spawnPiProcess): Promise<ScoutOutcome[]> {
-  const requests: AgentRequest[] = request.domains.map((domain) => ({
+  // Each scout gets the files most likely to answer its own instruction and focus.
+  const likely = await Promise.all(request.domains.map((domain) => likelyFor(request.hints, `${request.instruction}\n${domainSpec(domain).scoutFocus}`, request.signal, request.taskText)));
+  const extraTools = request.hints?.tools() ?? [];
+  const requests: AgentRequest[] = request.domains.map((domain, index) => ({
     taskId: request.taskId,
     domain,
     role: "scout",
     instruction: scoutInstruction(request, domain),
-    context: scoutContext(request, domain),
+    context: scoutContext(request, domain, likely[index]),
+    ...(extraTools.length > 0 ? { extraTools } : {}),
     ...profileFields(request.config, request.profile, domain, "scout"),
     cwd: request.cwd,
     signal: request.signal,
     onUpdate: request.onUpdate,
     ...watchdogOptions(request.config.workflow),
   }));
-  const runs = await runParallel(requests, request.config.workflow.maxParallelScouts, run);
-  const outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));
+  // Scouts think at a fixed level; a trivial one may move to the cheaper model.
+  const routes = await Promise.all(requests.map((entry) => routeFor(request.effort, entry.instruction, { ...(entry.model ? { model: entry.model } : {}), thinking: entry.thinking ?? "low" }, { thinkingFixed: true, context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) })));
+  const first = requests.map((entry, index) => (routes[index] ? { ...entry, ...routedFields(routes[index]!) } : entry));
+  const runs = await runParallel(first, request.config.workflow.maxParallelScouts, run);
+  let outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));
+  // A routed scout that came back unusable runs again on its configured model.
+  const again = outcomes.map((outcome, index) => (routes[index] && !outcome.usable && outcome.run.status !== "cancelled" && !request.signal?.aborted ? index : -1)).filter((index) => index >= 0);
+  if (again.length > 0) {
+    const reruns = await runParallel(again.map((index) => requests[index]!), request.config.workflow.maxParallelScouts, run);
+    outcomes = outcomes.map((outcome, index) => {
+      const position = again.indexOf(index);
+      return position >= 0 ? toOutcome(reruns[position]!, reruns[position]!.domain) : outcome;
+    });
+  }
   saveScoutResults(request.taskDir, outcomes);
   return outcomes;
 }
@@ -152,9 +199,13 @@ export interface WorkerRequest {
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
+  /** Likely files for the worker's step, and the lookup tool, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Lowers thinking (or the model) for a step the classifier judges simple or trivial. */
+  effort?: EffortRouter;
 }
 
-function workerWorkflowContext(request: WorkerRequest): string {
+function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
   const spec = domainSpec(request.domain);
   const own = request.scoutOutcomes.filter(
     (outcome) => outcome.result.domain === request.domain && outcome.usable,
@@ -166,7 +217,8 @@ function workerWorkflowContext(request: WorkerRequest): string {
     own.length > 0
       ? `Scout findings for your domain:\n${summarizeOutcomes(own, 1500)}`
       : "No scout findings were collected for your domain; verify the repository yourself.",
-  ].join("\n\n");
+    likely,
+  ].filter(Boolean).join("\n\n");
 }
 
 /** Delegate one implementation step to a domain worker. */
@@ -176,28 +228,42 @@ export async function runWorker(
 ): Promise<WorkerOutcome> {
   const slices = readAgentKnowledge(request.dataRoots, request.domain);
   const selected = selectKnowledge(`${request.taskText} ${request.instruction}`, slices);
-  const agentRun = await runAgent(
-    {
-      taskId: request.taskId,
-      domain: request.domain,
-      role: "worker",
-      instruction: request.instruction,
-      context: {
-        task: request.taskText,
-        ...selected,
-        instructions: request.config.agents[request.domain].instructions,
-        workflowContext: workerWorkflowContext(request),
-      },
-      ...profileFields(request.config, request.profile, request.domain, "worker"),
-      cwd: request.cwd,
-      signal: request.signal,
-      onUpdate: request.onUpdate,
-      ...watchdogOptions(request.config.workflow),
-      ...request.agent,
+  const configured = profileFields(request.config, request.profile, request.domain, "worker");
+  const [likely, route] = await Promise.all([
+    likelyFor(request.hints, request.instruction, request.signal, request.taskText),
+    routeFor(request.effort, request.instruction, { ...(configured.model ? { model: configured.model } : {}), thinking: configured.thinking }, { context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) }),
+  ]);
+  const hintTools = request.hints?.tools() ?? [];
+  const extraTools = [...(request.agent?.extraTools ?? []), ...hintTools];
+  const base: AgentRequest = {
+    taskId: request.taskId,
+    domain: request.domain,
+    role: "worker",
+    instruction: request.instruction,
+    context: {
+      task: request.taskText,
+      ...selected,
+      instructions: request.config.agents[request.domain].instructions,
+      workflowContext: workerWorkflowContext(request, likely),
     },
-    run,
-  );
-  const result = parseWorkerResult(request.domain, agentRun.output);
+    ...configured,
+    cwd: request.cwd,
+    signal: request.signal,
+    onUpdate: request.onUpdate,
+    ...watchdogOptions(request.config.workflow),
+    ...request.agent,
+    ...(extraTools.length > 0 ? { extraTools } : {}),
+  };
+  let outcome = workerOutcome(request.domain, await runAgent(route ? { ...base, ...routedFields(route) } : base, run));
+  // A routed step that fell short runs again at the configured model and thinking.
+  if (route && fellShort(outcome.run, outcome.issues) && !request.signal?.aborted) {
+    outcome = workerOutcome(request.domain, await runAgent(base, run));
+  }
+  return outcome;
+}
+
+function workerOutcome(domain: Domain, agentRun: AgentRun): WorkerOutcome {
+  const result = parseWorkerResult(domain, agentRun.output);
   const issues =
     agentRun.status === "success"
       ? validateWorkerResult(result)

package/src/pi/commands.ts

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
@@ -18,7 +19,8 @@ import { readFirstExisting } from "../knowledge/store.ts";
 import { overThreshold } from "../knowledge/compactor.ts";
 import { applyApprovalChoice, describeTask, describeOversizedKnowledge, type ApprovalChoice } from "../workflow/workflow.ts";
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
-import { openSettings } from "./settings-ui.ts";
+import { classifierSummary, openSettings } from "./settings-ui.ts";
+import { keyStatus } from "../classifier/instance.ts";
 import { kickoff, startPlannedTask, startTask } from "./start-task.ts";
 import { setAuto, toggleOwnAuto } from "./owner.ts";
 import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
@@ -43,11 +45,12 @@ const HELP = [
   "/bot-lobby claim <taskId>    Take ownership of an orphaned task",
   "/bot-lobby auto [on|off]    Auto mode: the oracle drives this session's task without asking (alt+g)",
   "/bot-lobby start-plan PLAN-… [auto]   Start a planned task here; its agreed plan needs no approval",
+  "/bot-lobby switch <session.jsonl>   Run a saved session in this window (the lobby's session browser uses it: alt+o, s)",
   "/bot-lobby help             This help",
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch"]);
 
 function isTaskId(value: string | undefined): boolean {
   return Boolean(value && /^TASK-/.test(value));
@@ -62,7 +65,8 @@ export function parseCommand(args: string): { sub: string | undefined; rest: str
   if (!sub || !SUBCOMMANDS.has(sub)) return { sub: undefined, rest: [], restText: trimmed };
   const takesArgs = sub === "amend" || sub === "claim"
     || (sub === "auto" && rest.length === 1 && /^(on|off)$/i.test(rest[0]!))
-    || (sub === "start-plan" && rest.length >= 1 && rest.length <= 2 && /^PLAN-/.test(rest[0]!) && (rest.length === 1 || rest[1] === "auto"));
+    || (sub === "start-plan" && rest.length >= 1 && rest.length <= 2 && /^PLAN-/.test(rest[0]!) && (rest.length === 1 || rest[1] === "auto"))
+    || (sub === "switch" && rest.length >= 1 && /\.jsonl$/.test(rest.join(" ")));
   if (!takesArgs && rest.length > 0 && !(rest.length === 1 && isTaskId(rest[0]))) {
     return { sub: undefined, rest: [], restText: trimmed };
   }
@@ -194,7 +198,21 @@ function showConfig(ctx: ExtensionCommandContext): void {
   const warnings = thinkingMismatches(config, modelLookup(ctx), ctx.model ? modelRef(ctx.model) : undefined);
   if (hasScoutThinking(readRawConfig())) warnings.push(`Scout: thinking is fixed at "${SCOUT_THINKING}"; the scout.thinking value in the file is ignored.`);
   const notes = warnings.length > 0 ? `\n\nWarnings:\n${warnings.map((line) => `- ${line}`).join("\n")}` : "";
-  ctx.ui.notify(`${globalConfigPath()}\n${JSON.stringify(config, null, 2)}${notes}`, warnings.length > 0 ? "warning" : "info");
+  const jev = `Classifier: ${classifierSummary(config, keyStatus)}`;
+  ctx.ui.notify(`${globalConfigPath()}\n${jev}\n${JSON.stringify(config, null, 2)}${notes}`, warnings.length > 0 ? "warning" : "info");
+}
+
+/**
+ * `/bot-lobby switch <file>`: run a saved session in this window. Only a
+ * command context may replace the session, so the lobby's browser asks for a
+ * switch through this command. The context is stale once the switch starts.
+ */
+async function switchCommand(ctx: ExtensionCommandContext, path: string): Promise<void> {
+  if (!existsSync(path)) return ctx.ui.notify(`bot-lobby: no session file at ${path}`, "warning");
+  if (ctx.sessionManager.getSessionFile() === path) return ctx.ui.notify("bot-lobby: this window already runs that session", "info");
+  if (!ctx.isIdle()) return ctx.ui.notify("bot-lobby: the oracle is working — esc stops it, then switch", "warning");
+  const result = await ctx.switchSession(path);
+  if (result.cancelled) ctx.ui.notify("bot-lobby: the switch was cancelled", "warning");
 }
 
 /** `/bot-lobby auto [on|off]`: switch (or set) auto mode for this session's task. */
@@ -265,6 +283,8 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return claimTaskCommand(ctx, configDir, rest[0]);
         case "auto":
           return autoCommand(ctx, configDir, rest[0]);
+        case "switch":
+          return switchCommand(ctx, restText);
         case "start-plan": {
           const started = await startPlannedTask(pi, ctx, configDir, rest[0]!, { auto: rest[1] === "auto" });
           if (typeof started === "string") return ctx.ui.notify(`bot-lobby: ${started}`, "warning");

package/src/pi/events.ts

@@ -11,9 +11,18 @@ import { applyStatus, clearStatus, isMinimized, setMinimized, setOracleActivity
 import { ORACLE_THINKING, oracleActivityWord } from "./activity.ts";
 import { isSubagentProcess, visibleTools } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
-import { taskRequest, type Task } from "../schemas/task.ts";
+import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
 import { pendingComments, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
+import { triageContext } from "../classifier/triage.ts";
+
+/** States in which the triage still helps the Master shape the task; once it is planned, the hints are noise. */
+const SHAPING_STATES: ReadonlySet<TaskState> = new Set(["created", "clarifying", "scouting", "synthesizing", "awaiting_approval"]);
+
+/** The Master's workflow context: the task's state, plus the classifier's triage while the task is being shaped. */
+export function masterWorkflowContext(task: Task): string {
+  return [describeTask(task), SHAPING_STATES.has(task.state) ? triageContext(task.triage) : ""].filter(Boolean).join("\n\n");
+}
 
 export function masterTaskContext(task: Task, comments: readonly PlanComment[] = [], auto = false): string {
   const open = pendingComments(comments);
@@ -96,7 +105,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       standards: selected.standards,
       knowledge: selected.knowledge,
       decisions: selected.decisions,
-      workflowContext: describeTask(task),
+      workflowContext: masterWorkflowContext(task),
       instructions: loadConfig().master.instructions,
     });
   });

package/src/pi/owner.ts

@@ -1,10 +1,11 @@
 /**
- * What a session does for the task it drives, on its own clock. Every few
- * seconds a session that owns a task (in the terminal or headless, started
- * from another window's lobby) passes on what other sessions left for its
- * oracle, plan comments and inbox messages, and in auto mode keeps the oracle
- * going whenever its turn ends before the task is done. Subagents never own
- * tasks, so none of this runs in them.
+ * What a session does on its own clock. Every few seconds a session (in the
+ * terminal or headless, started from another window's lobby) refreshes its
+ * heartbeat so other windows see it running, passes on what other sessions
+ * left for its oracle — plan comments, messages for its task or for the
+ * session itself — and in auto mode keeps the oracle going whenever its turn
+ * ends before the task is done. Subagents never own tasks or show up as
+ * sessions, so none of this runs in them.
  */
 import type { KeyId } from "@earendil-works/pi-tui";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -12,7 +13,8 @@ import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { activeTask, loadTask } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { commentMessage, markCommentsDelivered, readPlanComments, undeliveredComments } from "../state/comments.ts";
-import { inboxMessage, markInboxDelivered, readInbox } from "../state/inbox.ts";
+import { inboxMessage, markInboxDelivered, markSessionInboxDelivered, readInbox, readSessionInbox } from "../state/inbox.ts";
+import { removePresence, writePresence } from "../state/presence.ts";
 import { isAutoMode, setAutoMode } from "../state/auto.ts";
 import { isSubagentProcess } from "./quiet.ts";
 import { isMinimized } from "./ui.ts";
@@ -26,6 +28,7 @@ export const AUTO_KEY = "alt+g";
 
 export type OwnerEvent =
   | { kind: "comments" | "inbox"; taskId: string; count: number }
+  | { kind: "messages"; count: number }
   | { kind: "auto"; taskId: string; on: boolean }
   | { kind: "nudge"; taskId: string }
   | { kind: "stalled"; taskId: string };
@@ -33,6 +36,8 @@ export type OwnerEvent =
 interface Owner {
   pi: ExtensionAPI;
   ctx: ExtensionContext;
+  /** The session this clock runs for, kept so its heartbeat can be removed after its context goes stale. */
+  sessionId: string;
   root: string;
   configDir: string;
   timer?: ReturnType<typeof setInterval>;
@@ -84,6 +89,40 @@ export function deliverInbox(): number {
   return fresh.length;
 }
 
+/** Pass messages other sessions left for this session itself (it may have no task) to its Master. */
+export function deliverSessionInbox(): number {
+  const state = owner;
+  if (!state) return 0;
+  const sessionId = state.ctx.sessionManager.getSessionId();
+  const fresh = readSessionInbox(state.root, state.configDir, sessionId).filter((message) => !message.delivered);
+  if (fresh.length === 0) return 0;
+  state.pi.sendUserMessage(inboxMessage(fresh), state.ctx.isIdle() ? undefined : { deliverAs: "steer" });
+  markSessionInboxDelivered(state.root, state.configDir, sessionId, fresh.map((message) => message.id));
+  listener?.({ kind: "messages", count: fresh.length });
+  return fresh.length;
+}
+
+/** Tell other windows this session is running: its name, file, task and process. */
+export function heartbeat(): void {
+  const state = owner;
+  if (!state) return;
+  const name = state.pi.getSessionName?.();
+  const sessionFile = state.ctx.sessionManager.getSessionFile?.();
+  const task = ownTask(state);
+  try {
+    writePresence(state.root, state.configDir, {
+      sessionId: state.ctx.sessionManager.getSessionId(),
+      pid: process.pid,
+      mode: state.ctx.mode ?? "tui",
+      ...(name ? { name } : {}),
+      ...(sessionFile ? { sessionFile } : {}),
+      ...(live(task) ? { taskId: task.id } : {}),
+    });
+  } catch {
+    // A read-only project only means other windows do not see this one.
+  }
+}
+
 /** What auto mode remembers between nudges: the task as it was, and how many nudges changed nothing. */
 export interface AutoTrack {
   fingerprint: string;
@@ -172,13 +211,22 @@ export function toggleOwnAuto(): string {
 
 /** One tick of the owner's clock. */
 export function ownerTick(): void {
+  heartbeat();
   deliverComments();
   deliverInbox();
+  deliverSessionInbox();
   driveAuto();
 }
 
 function stop(): void {
   if (owner?.timer) clearInterval(owner.timer);
+  if (owner) {
+    try {
+      removePresence(owner.root, owner.configDir, owner.sessionId);
+    } catch {
+      // The heartbeat goes stale on its own.
+    }
+  }
   owner = undefined;
 }
 
@@ -186,7 +234,8 @@ function stop(): void {
 export function startOwner(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, pollMs = OWNER_POLL_MS): void {
   stop();
   if (isSubagentProcess()) return;
-  owner = { pi, ctx, root: detectProjectRoot(ctx.cwd, configDir), configDir };
+  owner = { pi, ctx, sessionId: ctx.sessionManager.getSessionId(), root: detectProjectRoot(ctx.cwd, configDir), configDir };
+  heartbeat();
   if (pollMs > 0) {
     owner.timer = setInterval(() => ownerTick(), pollMs);
     owner.timer.unref?.();

package/src/pi/run-summary.ts

@@ -42,8 +42,9 @@ const STATUS_ICONS: Record<AgentRun["status"], string> = {
 };
 
 /** Why a run ended the way it did, in words, when that is not plain success. */
-export function runFlags(run: Pick<AgentRun, "status" | "stalled" | "wrappedUp" | "attempts">): string[] {
+export function runFlags(run: Pick<AgentRun, "status" | "stalled" | "wrappedUp" | "attempts" | "route">): string[] {
   const flags: string[] = [];
+  if (run.route) flags.push(`routed ${run.route}`);
   if (run.stalled) flags.push("stalled");
   else if (run.status === "timeout") flags.push("hit its time limit");
   else if (run.status === "failed") flags.push("failed");
@@ -88,6 +89,7 @@ export function runLogEntry(run: AgentRun): RunLogEntry {
     ...(run.stalled ? { stalled: true } : {}),
     ...(run.wrappedUp ? { wrappedUp: true } : {}),
     ...(run.error ? { error: run.error.split("\n")[0]!.slice(0, 200) } : {}),
+    ...(run.routedFrom ? { routedFrom: run.routedFrom } : {}),
   };
 }
 

package/src/pi/settings-ui.ts

@@ -7,19 +7,25 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Container, type Component, type Focusable, fuzzyFilter, getKeybindings, Input, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
 import {
+  JEV_HOSTS,
   INHERIT_MODEL,
   isThinkingLevel,
   LOBBY_PANELS,
+  PLANNING_ROUND_CHOICES,
   SCOUT_THINKING,
   SUBAGENT_KINDS,
   type AgentModelConfig,
   type BotLobbyConfig,
+  type ClassifierFeature,
+  type JevHostName,
   type LobbyPanel,
   type SubagentKind,
 } from "../schemas/configuration.ts";
 import { globalConfigPath, loadConfig, saveConfig } from "../state/project.ts";
 import { checkThinking, kindLabel, modelRef, supportedThinking } from "./model-support.ts";
 import { modelLookup } from "./tools.ts";
+import { classifier } from "../classifier/instance.ts";
+import { describeKey, hostLabel, jevEndpoint, keyHint, maskKey, resolveKey, type StatusSource } from "../classifier/hosts.ts";
 
 const CUSTOM_MODEL = "__custom__";
 const MAX_VISIBLE = 12;
@@ -381,15 +387,29 @@ export function toggleLobbySwitch(config: BotLobbyConfig, id: LobbySwitch): BotL
   return { ...config, lobby: { ...config.lobby, [id]: value } };
 }
 
-/** On/off settings for the lobby; enter flips one and saves it. Key rebinding stays in the file (lobby.keys). */
+/** `5 rounds`, or `unlimited` for 0. */
+export function roundLimitLabel(limit: number): string {
+  return limit > 0 ? `${limit} round${limit === 1 ? "" : "s"}` : "unlimited";
+}
+
+/** The next planning round limit in the menu's cycle (2, 3, 5, 8, unlimited); a hand-edited value rejoins it. */
+export function nextRoundLimit(current: number): number {
+  const index = PLANNING_ROUND_CHOICES.indexOf(current as (typeof PLANNING_ROUND_CHOICES)[number]);
+  if (index >= 0) return PLANNING_ROUND_CHOICES[(index + 1) % PLANNING_ROUND_CHOICES.length]!;
+  return PLANNING_ROUND_CHOICES.find((choice) => choice > current) ?? 0;
+}
+
+/** On/off settings for the lobby, and the planning round limit; enter flips or cycles one and saves it. Key rebinding stays in the file (lobby.keys). */
 async function editLobby(ctx: ExtensionContext): Promise<void> {
   for (;;) {
     const config = loadConfig();
     const items: SelectItem[] = LOBBY_SWITCHES.map((entry) => ({ value: entry.id, label: entry.label, description: `${lobbySwitch(config, entry.id) ? "on" : "off"} · ${entry.help}` }));
+    items.push({ value: "rounds", label: "Planning rounds", description: `${roundLimitLabel(config.lobby.maxPlanningRounds)} · enter cycles 2, 3, 5, 8, unlimited; the last round the oracle settles alone` });
     items.push({ value: "back", label: "Back", description: `keys: lobby.keys in ${globalConfigPath()}` });
     const choice = await pick(ctx, "bot-lobby settings · Lobby", items);
     if (!choice || choice === "back") return;
-    saveConfig(toggleLobbySwitch(config, choice as LobbySwitch));
+    if (choice === "rounds") saveConfig({ ...config, lobby: { ...config.lobby, maxPlanningRounds: nextRoundLimit(config.lobby.maxPlanningRounds) } });
+    else saveConfig(toggleLobbySwitch(config, choice as LobbySwitch));
   }
 }
 
@@ -399,11 +419,125 @@ function lobbySummary(config: BotLobbyConfig): string {
     config.lobby.autoOpen ? "opens with a task" : "opens on alt+l",
     config.lobby.autoAsk ? "asks at once" : "asks on enter",
     config.lobby.mouse ? "mouse" : "no mouse",
+    `planning: ${roundLimitLabel(config.lobby.maxPlanningRounds)}`,
     ...(config.lobby.issues ? ["issues tab"] : []),
     ...(hidden.length > 0 ? [`hidden: ${hidden.join(", ")}`] : []),
   ].join(" · ");
 }
 
+/**
+ * Classifier decisions that exist so far, as the settings menu lists them.
+ * Each phase of the classifier work adds its own entry.
+ */
+export const CLASSIFIER_FEATURE_ITEMS: ReadonlyArray<{ id: ClassifierFeature; label: string; help: string }> = [
+  { id: "seats", label: "Planning seats", help: "each round, only the seats your idea or latest answers touch sit; 1-4 in the Plan tab pins one" },
+  { id: "answers", label: "Obvious answers", help: "a panel question whose recommended option the conversation already makes clearly right is answered for you (listed under Assumptions)" },
+  { id: "triage", label: "Task triage", help: "a new task's size, domains and research need reach the Master as hints; a quick fix that is really a task is held for you" },
+  { id: "effort", label: "Effort routing", help: "a simple step runs one thinking level lower, a trivial one on the cheaper model below; a routed run that falls short runs again on your settings" },
+  { id: "files", label: "File hints", help: "scouts, workers, quick fixes and the planning panel start with the files most likely needed, and can look more up with find_relevant_files" },
+];
+
+/** The next Jev host in the menu's cycle. */
+export function nextJevHost(current: JevHostName): JevHostName {
+  return JEV_HOSTS[(JEV_HOSTS.indexOf(current) + 1) % JEV_HOSTS.length]!;
+}
+
+/** The config with one classifier decision switched on or off. */
+export function toggleClassifierFeature(config: BotLobbyConfig, feature: ClassifierFeature): BotLobbyConfig {
+  const features = { ...config.classifier.features, [feature]: !config.classifier.features[feature] };
+  return { ...config, classifier: { ...config.classifier, features } };
+}
+
+/** `on · OpenCode Zen · jev-1.13-free · key stored in pi`, for the settings menu and `/bot-lobby config`. */
+export function classifierSummary(config: BotLobbyConfig, status: StatusSource | undefined): string {
+  const { host, model } = jevEndpoint(config.classifier, status);
+  const via = config.classifier.provider === "auto" ? `${host.label} (auto)` : host.label;
+  return [config.classifier.enabled ? "on" : "off", via, model, `key ${describeKey(host, status)}`].join(" · ");
+}
+
+/** pi's auth status per provider, never throwing. */
+function authStatus(ctx: ExtensionContext): StatusSource {
+  return (piProvider) => {
+    try {
+      return ctx.modelRegistry.getProviderAuthStatus(piProvider);
+    } catch {
+      return undefined;
+    }
+  };
+}
+
+/** Where the key lives and how to set it, with the loaded key masked. */
+async function keyHelp(ctx: ExtensionContext, config: BotLobbyConfig): Promise<string> {
+  const status = authStatus(ctx);
+  const { host } = jevEndpoint(config.classifier, status);
+  let masked = "";
+  try {
+    const key = await resolveKey(host, (provider) => ctx.modelRegistry.getApiKeyForProvider(provider));
+    if (key) masked = ` Loaded: ${maskKey(key)}.`;
+  } catch {
+    // No key to show.
+  }
+  const where = host.name === "opencode"
+    ? "it is the OpenCode key pi already uses for Zen and Go models"
+    : host.name === "typesafe" ? "it is saved in pi's auth.json with your other keys" : `it is the key pi already holds for ${host.label}`;
+  return `Jev via ${host.label}: key ${describeKey(host, status)}.${masked} To set it, ${keyHint(config.classifier)}; ${where}.`;
+}
+
+/** Type a Jev model id; empty uses the host's default (OpenCode: the free jev-1.13-free). */
+async function editJevModel(ctx: ExtensionContext): Promise<void> {
+  const config = loadConfig();
+  const { host } = jevEndpoint(config.classifier, authStatus(ctx));
+  const typed = await ctx.ui.input(`Jev model (empty: ${host.label}'s default, ${host.model})`, config.classifier.model || host.model);
+  if (typed === undefined) return;
+  const model = typed.trim() === host.model ? "" : typed.trim();
+  saveConfig({ ...config, classifier: { ...config.classifier, model } });
+  ctx.ui.notify(`bot-lobby: Jev model → ${model || `${host.model} (${host.label}'s default)`} — saved to ${globalConfigPath()}`, "info");
+}
+
+/** The model trivial steps run on; `none` keeps each agent's model and only lowers thinking. */
+async function editCheapModel(ctx: ExtensionContext): Promise<void> {
+  const config = loadConfig();
+  const current = config.classifier.effort.cheapModel;
+  const none: SelectItem = { value: INHERIT_MODEL, label: current === INHERIT_MODEL ? "none ✓" : "none", description: "Trivial steps keep their model and run one thinking level lower" };
+  const choice = await pick(ctx, "Cheaper model for trivial steps", [none, ...modelItems(ctx, current, false)], { search: true });
+  if (choice === undefined) return;
+  const typed = choice === CUSTOM_MODEL ? (await ctx.ui.input("Model id", "provider/model"))?.trim() : choice;
+  if (!typed) return;
+  saveConfig({ ...config, classifier: { ...config.classifier, effort: { cheapModel: typed } } });
+  ctx.ui.notify(`bot-lobby: trivial steps run on ${typed === INHERIT_MODEL ? "their own model, one thinking level lower" : typed} — saved to ${globalConfigPath()}`, "info");
+}
+
+/** The classifier: on/off, where Jev is called, its key, which decisions it makes, and a connection test. */
+async function editClassifier(ctx: ExtensionContext): Promise<void> {
+  for (;;) {
+    const config = loadConfig();
+    const settings = config.classifier;
+    const status = authStatus(ctx);
+    const { host, model } = jevEndpoint(settings, status);
+    const items: SelectItem[] = [
+      { value: "enabled", label: "Classifier", description: `${settings.enabled ? "on" : "off"} · Jev makes the obvious decisions so large models spend fewer tokens on them` },
+      { value: "host", label: "Host", description: `${hostLabel(settings.provider)}${settings.provider === "auto" ? ` → ${host.label}` : ""} · enter cycles ${JEV_HOSTS.map(hostLabel).join(", ")}` },
+      { value: "key", label: "API key", description: describeKey(host, status) },
+      { value: "model", label: "Model", description: `${model}${settings.model ? "" : " (the host's default)"} · e.g. jev-1.13 once OpenCode's free jev-1.13-free ends` },
+      ...CLASSIFIER_FEATURE_ITEMS.map((entry) => ({ value: `feature:${entry.id}`, label: entry.label, description: `${settings.features[entry.id] ? "on" : "off"} · ${entry.help}` })),
+      { value: "cheap", label: "Cheaper model", description: `${settings.effort.cheapModel === INHERIT_MODEL ? "none: trivial steps keep their model and drop a thinking level" : settings.effort.cheapModel} · what effort routing runs trivial steps on` },
+      { value: "test", label: "Test connection", description: "one tiny call: shows the model and how long it took" },
+      { value: "back", label: "Back", description: `thresholds and limits: classifier in ${globalConfigPath()}` },
+    ];
+    const choice = await pick(ctx, "bot-lobby settings · Classifier (Jev)", items);
+    if (!choice || choice === "back") return;
+    if (choice === "enabled") saveConfig({ ...config, classifier: { ...settings, enabled: !settings.enabled } });
+    else if (choice === "host") saveConfig({ ...config, classifier: { ...settings, provider: nextJevHost(settings.provider) } });
+    else if (choice === "key") ctx.ui.notify(await keyHelp(ctx, config), "info");
+    else if (choice === "model") await editJevModel(ctx);
+    else if (choice === "cheap") await editCheapModel(ctx);
+    else if (choice === "test") {
+      const result = await classifier().test();
+      ctx.ui.notify(result.ok ? `Jev answered in ${result.ms} ms (${result.model}).` : `Jev test failed: ${result.error}`, result.ok ? "info" : "error");
+    } else if (choice.startsWith("feature:")) saveConfig(toggleClassifierFeature(config, choice.slice("feature:".length) as ClassifierFeature));
+  }
+}
+
 /** Open the per-agent settings editor; every change is written to the global config. */
 export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
   if (ctx.mode !== "tui") {
@@ -419,10 +553,12 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
     const config = loadConfig();
     const items: SelectItem[] = SETTINGS_KINDS.map((kind) => ({ value: kind, label: kindLabel(kind), description: entryDescription(kind, entryView(config, kind)) }));
     items.push({ value: "lobby", label: "Lobby", description: lobbySummary(config) });
+    items.push({ value: "classifier", label: "Classifier (Jev)", description: classifierSummary(config, authStatus(ctx)) });
     items.push({ value: "close", label: "Close" });
     const choice = await pick(ctx, "bot-lobby settings", items);
     if (!choice || choice === "close") return;
     if (choice === "lobby") await editLobby(ctx);
+    else if (choice === "classifier") await editClassifier(ctx);
     else await editEntry(pi, ctx, choice as SettingsKind);
   }
 }

package/src/pi/start-task.ts

@@ -14,6 +14,7 @@ import { applyStatus } from "./ui.ts";
 import { applyMasterModel } from "./settings-ui.ts";
 import { setAutoMode } from "../state/auto.ts";
 import { loadPlannedTask, markPlannedTaskStarted, plannedTaskRequest } from "../state/backlog.ts";
+import { triageFor } from "../classifier/instance.ts";
 
 function uniqueTaskId(root: string, configDir: string, request: string): string {
   const base = nextTaskId(request);
@@ -65,6 +66,9 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   if (options.approvedPlan) task.approvedPlan = options.approvedPlan;
   createTaskDir(root, configDir, task);
   transition(task, "clarifying");
+  // The classifier's read of the request (when it is on) reaches the Master's very first turn.
+  const triage = await triageFor({ cwd: ctx.cwd, root, configDir }, request);
+  if (triage) task.triage = triage;
   saveTask(root, configDir, task);
   if (options.auto) setAutoMode(root, configDir, task.id, true, sessionId);
   // A session that starts a task is named after it, so /resume and the lobby list it by name.