@a-t-h-i/bot-lobby 0.3.0 → 0.4.0

package/src/pi/model-support.ts

@@ -0,0 +1,101 @@
+import { clampThinkingLevel, getSupportedThinkingLevels, type Api, type Model, type ModelThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  agentProfile,
+  isThinkingLevel,
+  THINKING_LEVELS,
+  type BotLobbyConfig,
+  type ProfileResolver,
+  type SubagentKind,
+  type ThinkingLevelName,
+} from "../schemas/configuration.ts";
+
+/** Find a model by `provider/id` (or bare id); undefined when the registry does not know it. */
+export type ModelLookup = (ref: string) => Model<Api> | undefined;
+
+export type { ProfileResolver };
+
+/** `provider/id` for a model, the form settings store. */
+export function modelRef(model: Pick<Model<Api>, "provider" | "id">): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/** Thinking levels a model supports, in pi's order; every level when the model is unknown. */
+export function supportedThinking(model: Model<Api> | undefined): ThinkingLevelName[] {
+  if (!model) return [...THINKING_LEVELS];
+  return getSupportedThinkingLevels(model).filter((level): level is ThinkingLevelName => isThinkingLevel(level));
+}
+
+export interface ThinkingCheck {
+  /** The level to run at: the requested one, or pi's nearest supported level. */
+  level: string;
+  /** Set when the requested level had to change. */
+  warning?: string;
+}
+
+/** Clamp `level` to what `model` supports, explaining any change; unknown models pass through. */
+export function checkThinking(model: Model<Api> | undefined, level: string): ThinkingCheck {
+  if (!model || !isThinkingLevel(level)) return { level };
+  const clamped = clampThinkingLevel(model, level as ModelThinkingLevel);
+  if (clamped === level) return { level };
+  return { level: clamped, warning: `"${level}" thinking isn't supported by ${modelRef(model)} — using "${clamped}"` };
+}
+
+const LABELS: Record<SubagentKind | "master", string> = {
+  master: "Master",
+  designer: "Designer",
+  backend: "Backend",
+  qa: "QA",
+  scout: "Scout",
+  researcher: "Researcher",
+};
+
+export function kindLabel(kind: SubagentKind | "master"): string {
+  return LABELS[kind];
+}
+
+export interface ResolverOptions {
+  lookup: ModelLookup;
+  /** The session's model as `provider/id`; used only where settings name no model yet. */
+  sessionModel?: string;
+  /** Receives each distinct clamp warning once per process. */
+  warn?: (message: string) => void;
+}
+
+const warned = new Set<string>();
+
+/**
+ * Profiles straight from settings, with the thinking level clamped to what
+ * each model supports. A subagent whose model is still unset runs on the
+ * session's model (named explicitly on the command line) until settings pin one.
+ */
+export function createProfileResolver(config: BotLobbyConfig, options: ResolverOptions): ProfileResolver {
+  return (domain, role) => {
+    const profile = agentProfile(config, domain, role);
+    const model = profile.model ?? options.sessionModel;
+    const check = checkThinking(model ? options.lookup(model) : undefined, profile.thinking);
+    if (check.warning) {
+      const message = `bot-lobby: ${kindLabel(profile.kind)} — ${check.warning}. Change it in /bot-lobby settings.`;
+      if (!warned.has(message)) {
+        warned.add(message);
+        options.warn?.(message);
+      }
+    }
+    return { ...profile, model, thinking: check.level };
+  };
+}
+
+/** Every configured subagent whose thinking level its model does not support, for `/bot-lobby config`. */
+export function thinkingMismatches(config: BotLobbyConfig, lookup: ModelLookup, sessionModel?: string): string[] {
+  const entries: Array<[SubagentKind | "master", string, string]> = [
+    ["master", config.master.model, config.master.thinking],
+    ["designer", config.agents.designer.model, config.agents.designer.thinking],
+    ["backend", config.agents.backend.model, config.agents.backend.thinking],
+    ["qa", config.agents.qa.model, config.agents.qa.thinking],
+    ["researcher", config.researcher.model, config.researcher.thinking],
+  ];
+  return entries.flatMap(([kind, ref, level]) => {
+    const model = ref === "inherit" ? sessionModel : ref;
+    const check = checkThinking(model ? lookup(model) : undefined, level);
+    return check.warning ? [`${kindLabel(kind)}: ${check.warning}`] : [];
+  });
+}

package/src/pi/run-summary.ts

@@ -0,0 +1,170 @@
+/**
+ * One-line descriptions of subagent runs, shared by the transcript entries,
+ * `/bot-lobby runs`, the Master's reports and the zen feed row. Pure: every
+ * clock read arrives as `now`.
+ */
+import type { AgentRun } from "../schemas/findings.ts";
+import type { RunLogEntry } from "../schemas/task.ts";
+import { shortDuration } from "../text.ts";
+import { SLOT_LABELS, type SlotId } from "./mascot-art.ts";
+
+/** The zen column a run belongs to; a researcher reports under RESEARCH from any domain. */
+export function slotOf(run: Pick<AgentRun, "domain" | "role">): SlotId {
+  if (run.role === "researcher") return "research";
+  if (run.domain === "backend") return "dev";
+  return run.domain === "designer" ? "design" : "qa";
+}
+
+/** Upper-case agent name as the scene shows it (DEV, DESIGN, RESEARCH, QA). */
+export function agentName(run: Pick<AgentRun, "domain" | "role">): string {
+  return SLOT_LABELS[slotOf(run)];
+}
+
+/** Compact token count: 950, 41k, 1.2M. */
+export function tokens(count: number): string {
+  if (!Number.isFinite(count) || count < 1000) return String(Math.max(0, Math.round(count || 0)));
+  if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+  return `${(count / 1_000_000).toFixed(1)}M`;
+}
+
+function durationOf(run: Pick<AgentRun, "startedAt" | "finishedAt">, now: number): number {
+  const end = run.finishedAt ? Date.parse(run.finishedAt) : now;
+  const elapsed = end - Date.parse(run.startedAt);
+  return Number.isFinite(elapsed) && elapsed > 0 ? elapsed : 0;
+}
+
+const STATUS_ICONS: Record<AgentRun["status"], string> = {
+  running: "◐",
+  success: "✓",
+  failed: "✗",
+  cancelled: "·",
+  timeout: "✗",
+};
+
+/** 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[] {
+  const flags: string[] = [];
+  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");
+  else if (run.status === "cancelled") flags.push("cancelled");
+  if (run.wrappedUp) flags.push(run.status === "success" ? "wrapped up early — report may be partial" : "asked to wrap up");
+  if (run.attempts > 1) flags.push(`${run.attempts} attempts`);
+  return flags;
+}
+
+/**
+ * `✓ DEV worker · 3m 12s · 9 turns · 23 tools · 41k↑ 6k↓ · $0.12 · provider/model`,
+ * followed by any flags (stalled, time limit, wrapped up early, attempts).
+ */
+export function describeRun(run: AgentRun, now = Date.now()): string {
+  const parts = [`${STATUS_ICONS[run.status]} ${agentName(run)} ${run.role}`, shortDuration(durationOf(run, now))];
+  const turns = run.turns ?? run.usage?.turns;
+  if (turns) parts.push(`${turns} turn${turns === 1 ? "" : "s"}`);
+  if (run.tools) parts.push(`${run.tools} tool${run.tools === 1 ? "" : "s"}`);
+  if (run.usage && (run.usage.input || run.usage.output)) parts.push(`${tokens(run.usage.input)}↑ ${tokens(run.usage.output)}↓`);
+  if (run.usage?.cost) parts.push(`$${run.usage.cost.toFixed(2)}`);
+  if (run.model) parts.push(run.model);
+  parts.push(...runFlags(run));
+  const line = parts.join(" · ");
+  return run.status === "success" || !run.error ? line : `${line} — ${run.error.split("\n")[0]}`;
+}
+
+/** The persisted form of a finished run, for `task.runLog`. */
+export function runLogEntry(run: AgentRun): RunLogEntry {
+  return {
+    runId: run.runId,
+    domain: run.domain,
+    role: run.role,
+    status: run.status,
+    startedAt: run.startedAt,
+    ...(run.finishedAt ? { finishedAt: run.finishedAt } : {}),
+    ...(run.model ? { model: run.model } : {}),
+    ...(run.turns ?? run.usage?.turns ? { turns: run.turns ?? run.usage?.turns } : {}),
+    ...(run.tools ? { tools: run.tools } : {}),
+    ...(run.usage ? { input: run.usage.input, output: run.usage.output, cost: run.usage.cost } : {}),
+    attempts: run.attempts,
+    ...(run.stalled ? { stalled: true } : {}),
+    ...(run.wrappedUp ? { wrappedUp: true } : {}),
+    ...(run.error ? { error: run.error.split("\n")[0]!.slice(0, 200) } : {}),
+  };
+}
+
+/** A persisted entry back as a run, so `describeRun` formats both the same way. */
+export function runFromLog(entry: RunLogEntry, taskId: string): AgentRun {
+  return {
+    runId: entry.runId,
+    taskId,
+    domain: entry.domain,
+    role: entry.role,
+    status: entry.status,
+    output: "",
+    attempts: entry.attempts ?? 1,
+    startedAt: entry.startedAt,
+    ...(entry.finishedAt ? { finishedAt: entry.finishedAt } : {}),
+    ...(entry.model ? { model: entry.model } : {}),
+    ...(entry.turns ? { turns: entry.turns } : {}),
+    ...(entry.tools ? { tools: entry.tools } : {}),
+    ...(entry.input !== undefined ? { usage: { input: entry.input, output: entry.output ?? 0, cost: entry.cost ?? 0, turns: entry.turns ?? 0 } } : {}),
+    ...(entry.stalled ? { stalled: true } : {}),
+    ...(entry.wrappedUp ? { wrappedUp: true } : {}),
+    ...(entry.error ? { error: entry.error } : {}),
+  };
+}
+
+/** Silence after which a working agent reads as "quiet" in the scene. */
+export const QUIET_MS = 45_000;
+
+/** How long a running agent has produced nothing, or 0 when it is not running or has no clock yet. */
+export function quietFor(run: Pick<AgentRun, "status" | "lastEventAt" | "startedAt">, now: number): number {
+  if (run.status !== "running") return 0;
+  const last = run.lastEventAt ?? Date.parse(run.startedAt);
+  const quiet = now - last;
+  return Number.isFinite(quiet) && quiet > 0 ? quiet : 0;
+}
+
+export interface FeedLine {
+  text: string;
+  kind: "info" | "warning";
+}
+
+/** Ticks one working agent holds the feed before it rotates to the next (~3 s at the live clock). */
+export const FEED_ROTATE_TICKS = 12;
+
+/** What one working agent is doing right now, with a warning when something needs attention. */
+function liveFeed(run: AgentRun, now: number): FeedLine {
+  const name = agentName(run);
+  if (run.waitingFor) return { text: `⧗ ${name} waiting for ${run.waitingFor}${run.note ? ` · ${run.note}` : ""}`, kind: "warning" };
+  const quiet = quietFor(run, now);
+  if (quiet >= QUIET_MS) {
+    const doing = run.activity ? ` (last: ${run.activity}${run.detail ? ` ${run.detail}` : ""})` : "";
+    return { text: `! ${name} quiet for ${shortDuration(quiet)}${doing}`, kind: "warning" };
+  }
+  if (run.note && run.noteKind === "warning") return { text: `! ${name} ${run.note}`, kind: "warning" };
+  const parts = [`▸ ${name} ${run.activity ?? "working"}${run.detail ? ` ${run.detail}` : ""}`];
+  const turns = run.turns ?? run.usage?.turns;
+  if (turns) parts.push(`turn ${turns}`);
+  if (run.tools) parts.push(`${run.tools} tools`);
+  if (run.usage && run.usage.input + run.usage.output > 0) parts.push(`${tokens(run.usage.input + run.usage.output)} tok`);
+  if (run.note) parts.push(run.note);
+  return { text: parts.join(" · "), kind: "info" };
+}
+
+/**
+ * The scene's feed row: a working agent that needs attention first, otherwise
+ * the working agents in rotation, otherwise the most recent finished run.
+ * Undefined before anything has run.
+ */
+export function feedLine(runs: readonly AgentRun[], now: number, tick: number): FeedLine | undefined {
+  const running = runs.filter((run) => run.status === "running");
+  if (running.length > 0) {
+    const lines = running.map((run) => liveFeed(run, now));
+    const warning = lines.find((line) => line.kind === "warning");
+    if (warning) return warning;
+    const index = Math.floor(Math.max(0, tick) / FEED_ROTATE_TICKS) % lines.length;
+    return lines[index];
+  }
+  const last = [...runs].filter((run) => run.finishedAt).sort((a, b) => Date.parse(a.finishedAt!) - Date.parse(b.finishedAt!)).at(-1);
+  if (!last) return undefined;
+  return { text: describeRun(last, now), kind: last.status === "success" && !last.wrappedUp ? "info" : "warning" };
+}

package/src/pi/settings-ui.ts

@@ -6,47 +6,71 @@ import {
   type Theme,
 } 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 { AGENT_KINDS, type AgentKind } from "../schemas/agent.ts";
 import {
   INHERIT_MODEL,
-  INHERIT_THINKING,
   isThinkingLevel,
-  THINKING_LEVELS,
+  SCOUT_THINKING,
+  SUBAGENT_KINDS,
   type AgentModelConfig,
   type BotLobbyConfig,
+  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";
 
 const CUSTOM_MODEL = "__custom__";
 const MAX_VISIBLE = 12;
 
-function agentLabel(agent: AgentKind): string {
-  return agent === "master" ? "Master" : `${agent[0]!.toUpperCase()}${agent.slice(1)}`;
+/** One settings entry: the master or a subagent profile. */
+export type SettingsKind = "master" | SubagentKind;
+export const SETTINGS_KINDS: readonly SettingsKind[] = ["master", ...SUBAGENT_KINDS];
+
+/** The editable fields of one entry; scouts have no thinking and no instructions of their own. */
+interface EntryView {
+  model: string;
+  thinking?: string;
+  instructions?: string;
+  timeoutMs?: number;
+}
+
+function entryView(config: BotLobbyConfig, kind: SettingsKind): EntryView {
+  if (kind === "master") return config.master;
+  if (kind === "scout") return { model: config.scout.model, timeoutMs: config.scout.timeoutMs };
+  if (kind === "researcher") return config.researcher;
+  return config.agents[kind];
 }
 
-function agentConfig(config: BotLobbyConfig, agent: AgentKind): AgentModelConfig {
-  return agent === "master" ? config.master : config.agents[agent];
+interface EntryPatch {
+  model?: string;
+  thinking?: string;
+  instructions?: string;
+  timeoutMs?: number;
 }
 
-function updateAgent(agent: AgentKind, patch: Partial<AgentModelConfig>): void {
-  const config = loadConfig();
-  if (agent === "master") config.master = { ...config.master, ...patch };
-  else config.agents[agent] = { ...config.agents[agent], ...patch };
-  saveConfig(config);
+/** Apply a patch to one entry in a config copy; scouts ignore thinking and instructions. */
+export function patchEntry(config: BotLobbyConfig, kind: SettingsKind, patch: EntryPatch): BotLobbyConfig {
+  const next: BotLobbyConfig = { ...config, agents: { ...config.agents } };
+  if (kind === "master") next.master = { ...config.master, ...patch } as AgentModelConfig;
+  else if (kind === "scout") {
+    next.scout = {
+      model: patch.model ?? config.scout.model,
+      timeoutMs: patch.timeoutMs ?? config.scout.timeoutMs,
+    };
+  } else if (kind === "researcher") next.researcher = { ...config.researcher, ...patch } as AgentModelConfig;
+  else next.agents[kind] = { ...config.agents[kind], ...patch } as AgentModelConfig;
+  return next;
 }
 
-/** Find a `provider/id` (or bare id) among the models this session can use. */
-function findModel(ctx: ExtensionContext, ref: string) {
-  const slash = ref.indexOf("/");
-  if (slash > 0) return ctx.modelRegistry.find(ref.slice(0, slash), ref.slice(slash + 1));
-  return ctx.modelRegistry.getAvailable().find((model) => model.id === ref);
+function updateEntry(kind: SettingsKind, patch: EntryPatch): void {
+  saveConfig(patchEntry(loadConfig(), kind, patch));
 }
 
 /** Apply the master model/thinking to the live session; "inherit" leaves it alone. */
 export async function applyMasterModel(pi: ExtensionAPI, ctx: ExtensionContext, config: BotLobbyConfig): Promise<void> {
   const { model, thinking } = config.master;
   if (model !== INHERIT_MODEL) {
-    const found = findModel(ctx, model);
+    const found = modelLookup(ctx)(model);
     if (!found) ctx.ui.notify(`bot-lobby: unknown master model "${model}".`, "warning");
     else if (!(await pi.setModel(found))) ctx.ui.notify(`bot-lobby: no auth for ${model}.`, "warning");
   }
@@ -173,9 +197,13 @@ async function pick(ctx: ExtensionContext, title: string, items: SelectItem[], o
   return options.search ? pickSearch(ctx, title, items) : pickPlain(ctx, title, items);
 }
 
-export function modelItems(ctx: ExtensionContext, current: string): SelectItem[] {
-  const inherit = current === INHERIT_MODEL ? `${INHERIT_MODEL} ✓` : INHERIT_MODEL;
-  const items: SelectItem[] = [{ value: INHERIT_MODEL, label: inherit, description: "Use the session's current model" }];
+/** Model choices; only the master offers `inherit`, since it is the live session itself. */
+export function modelItems(ctx: ExtensionContext, current: string, includeInherit = true): SelectItem[] {
+  const items: SelectItem[] = [];
+  if (includeInherit) {
+    const inherit = current === INHERIT_MODEL ? `${INHERIT_MODEL} ✓` : INHERIT_MODEL;
+    items.push({ value: INHERIT_MODEL, label: inherit, description: "Use the session's current model" });
+  }
   const usable = ctx.scopedModels.length > 0 ? ctx.scopedModels.map((entry) => entry.model) : ctx.modelRegistry.getAvailable();
   for (const model of usable) {
     const value = `${model.provider}/${model.id}`;
@@ -187,54 +215,123 @@ export function modelItems(ctx: ExtensionContext, current: string): SelectItem[]
   return items;
 }
 
-async function commit(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind, patch: Partial<AgentModelConfig>, detail: string): Promise<void> {
-  updateAgent(agent, patch);
-  if (agent === "master") await applyMasterModel(pi, ctx, loadConfig());
-  ctx.ui.notify(`bot-lobby: ${agent} ${detail} — saved to ${globalConfigPath()}`, "info");
+/** The model an entry runs on: its own, or the session's while unset. */
+function effectiveModel(ctx: ExtensionContext, model: string) {
+  if (model !== INHERIT_MODEL) return modelLookup(ctx)(model);
+  return ctx.model;
+}
+
+/** Thinking choices limited to what the entry's model supports. */
+export function thinkingItems(levels: readonly string[], current: string | undefined): SelectItem[] {
+  return levels.map((level) => (level === current ? { value: level, label: `${level} ✓` } : { value: level, label: level }));
 }
 
-async function editModel(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
-  const current = agentConfig(loadConfig(), agent).model;
-  const choice = await pick(ctx, `Model — ${agentLabel(agent)}`, modelItems(ctx, current), { search: true });
+async function commit(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind, patch: EntryPatch, detail: string): Promise<void> {
+  updateEntry(kind, patch);
+  if (kind === "master") await applyMasterModel(pi, ctx, loadConfig());
+  ctx.ui.notify(`bot-lobby: ${kindLabel(kind)} ${detail} — saved to ${globalConfigPath()}`, "info");
+}
+
+/** After a model change, clamp a saved thinking level the new model cannot run, and say so. */
+async function reconcileThinking(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const view = entryView(loadConfig(), kind);
+  if (!view.thinking) return;
+  const check = checkThinking(effectiveModel(ctx, view.model), view.thinking);
+  if (!check.warning) return;
+  updateEntry(kind, { thinking: check.level });
+  if (kind === "master") await applyMasterModel(pi, ctx, loadConfig());
+  ctx.ui.notify(`bot-lobby: ${kindLabel(kind)} — ${check.warning}.`, "warning");
+}
+
+async function editModel(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const current = entryView(loadConfig(), kind).model;
+  const choice = await pick(ctx, `Model — ${kindLabel(kind)}`, modelItems(ctx, current, kind === "master"), { search: true });
   if (choice === undefined) return;
   const typed = choice === CUSTOM_MODEL ? (await ctx.ui.input("Model id", "provider/model"))?.trim() : choice;
   if (!typed) return;
-  await commit(pi, ctx, agent, { model: typed }, `model → ${typed}`);
+  await commit(pi, ctx, kind, { model: typed }, `model → ${typed}`);
+  await reconcileThinking(pi, ctx, kind);
 }
 
-async function editThinking(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
-  const current = agentConfig(loadConfig(), agent).thinking;
-  const items: SelectItem[] = [
-    { value: INHERIT_THINKING, label: `${INHERIT_THINKING} (live session level)`, description: "Use the thinking level of the current session" },
-    ...THINKING_LEVELS.map((level) => ({ value: level, label: level })),
-  ].map((item) => (item.value === current ? { ...item, label: `${item.label} ✓` } : item));
-  const level = await pick(ctx, `Thinking — ${agentLabel(agent)}`, items);
-  if (!level) return;
-  await commit(pi, ctx, agent, { thinking: level }, `thinking → ${level}`);
+async function editThinking(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const view = entryView(loadConfig(), kind);
+  const model = effectiveModel(ctx, view.model);
+  const levels = supportedThinking(model);
+  const title = model ? `Thinking — ${kindLabel(kind)} (${modelRef(model)})` : `Thinking — ${kindLabel(kind)}`;
+  const level = await pick(ctx, title, thinkingItems(levels, view.thinking));
+  if (!level || !isThinkingLevel(level)) return;
+  await commit(pi, ctx, kind, { thinking: level }, `thinking → ${level}`);
+}
+
+async function editTimeout(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const current = entryView(loadConfig(), kind).timeoutMs ?? loadConfig().workflow.agentTimeoutMs;
+  const typed = (await ctx.ui.input(`Time limit (minutes) — ${kindLabel(kind)}`, String(Math.round(current / 60_000))))?.trim();
+  if (!typed) return;
+  const minutes = Number(typed);
+  if (!Number.isFinite(minutes) || minutes <= 0) {
+    ctx.ui.notify(`bot-lobby: "${typed}" is not a positive number of minutes.`, "warning");
+    return;
+  }
+  await commit(pi, ctx, kind, { timeoutMs: Math.round(minutes * 60_000) }, `time limit → ${minutes}m`);
 }
 
-async function editInstructions(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
-  const current = agentConfig(loadConfig(), agent).instructions ?? "";
-  const text = await ctx.ui.editor(`Instructions — ${agentLabel(agent)}`, current);
+async function editInstructions(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
+  const current = entryView(loadConfig(), kind).instructions ?? "";
+  const text = await ctx.ui.editor(`Instructions — ${kindLabel(kind)}`, current);
   if (text === undefined) return;
-  await commit(pi, ctx, agent, { instructions: text.trim() }, "instructions saved");
+  await commit(pi, ctx, kind, { instructions: text.trim() }, "instructions saved");
+}
+
+function minutes(ms: number | undefined): string {
+  return ms ? `${Math.round(ms / 60_000)}m` : "default";
+}
+
+/** Menu rows for one entry; scouts expose model and time limit only (their thinking is fixed). */
+export function entryItems(kind: SettingsKind, view: EntryView): SelectItem[] {
+  const items: SelectItem[] = [{ value: "model", label: "Model", description: view.model }];
+  if (kind === "scout") items.push({ value: "fixed", label: "Thinking", description: `${SCOUT_THINKING} (fixed for scouts)` });
+  else items.push({ value: "thinking", label: "Thinking", description: view.thinking ?? "" });
+  if (kind !== "master") items.push({ value: "timeout", label: "Time limit", description: minutes(view.timeoutMs) });
+  if (kind !== "scout" && kind !== "researcher") {
+    items.push({ value: "instructions", label: "Instructions", description: view.instructions ? `${view.instructions.length} chars` : "(none)" });
+  }
+  items.push({ value: "back", label: "Back" });
+  return items;
 }
 
-async function editAgent(pi: ExtensionAPI, ctx: ExtensionContext, agent: AgentKind): Promise<void> {
+async function editEntry(pi: ExtensionAPI, ctx: ExtensionContext, kind: SettingsKind): Promise<void> {
   for (;;) {
-    const cfg = agentConfig(loadConfig(), agent);
-    const items: SelectItem[] = [
-      { value: "model", label: "Model", description: cfg.model },
-      { value: "thinking", label: "Thinking", description: cfg.thinking },
-      { value: "instructions", label: "Instructions", description: cfg.instructions ? `${cfg.instructions.length} chars` : "(none)" },
-      { value: "back", label: "Back" },
-    ];
-    const action = await pick(ctx, `${agentLabel(agent)} settings`, items);
+    const action = await pick(ctx, `${kindLabel(kind)} settings`, entryItems(kind, entryView(loadConfig(), kind)));
     if (!action || action === "back") return;
-    if (action === "model") await editModel(pi, ctx, agent);
-    else if (action === "thinking") await editThinking(pi, ctx, agent);
-    else await editInstructions(pi, ctx, agent);
+    if (action === "model") await editModel(pi, ctx, kind);
+    else if (action === "thinking") await editThinking(pi, ctx, kind);
+    else if (action === "timeout") await editTimeout(pi, ctx, kind);
+    else if (action === "instructions") await editInstructions(pi, ctx, kind);
+  }
+}
+
+/**
+ * Subagents never inherit silently: any subagent whose model is still unset is
+ * pinned to the session's current model and saved, so settings always show
+ * what each agent runs on.
+ */
+export function prefillModels(config: BotLobbyConfig, sessionModel: string | undefined): { config: BotLobbyConfig; filled: SubagentKind[] } {
+  if (!sessionModel) return { config, filled: [] };
+  let next = config;
+  const filled: SubagentKind[] = [];
+  for (const kind of SUBAGENT_KINDS) {
+    if (entryView(next, kind).model !== INHERIT_MODEL) continue;
+    next = patchEntry(next, kind, { model: sessionModel });
+    filled.push(kind);
   }
+  return { config: next, filled };
+}
+
+function entryDescription(kind: SettingsKind, view: EntryView): string {
+  const thinking = kind === "scout" ? SCOUT_THINKING : view.thinking;
+  const custom = view.instructions ? " · custom" : "";
+  const limit = kind === "master" ? "" : ` · ${minutes(view.timeoutMs)}`;
+  return `${view.model} · ${thinking}${limit}${custom}`;
 }
 
 /** Open the per-agent settings editor; every change is written to the global config. */
@@ -243,16 +340,17 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
     ctx.ui.notify(`bot-lobby settings live in ${globalConfigPath()}; edit that file outside the TUI.`, "info");
     return;
   }
+  const prefilled = prefillModels(loadConfig(), ctx.model ? modelRef(ctx.model) : undefined);
+  if (prefilled.filled.length > 0) {
+    saveConfig(prefilled.config);
+    ctx.ui.notify(`bot-lobby: set ${prefilled.filled.map(kindLabel).join(", ")} to the session model; change them here any time.`, "info");
+  }
   for (;;) {
     const config = loadConfig();
-    const items: SelectItem[] = AGENT_KINDS.map((agent) => {
-      const cfg = agentConfig(config, agent);
-      const custom = cfg.instructions ? " · custom" : "";
-      return { value: agent, label: agentLabel(agent), description: `${cfg.model} · ${cfg.thinking}${custom}` };
-    });
+    const items: SelectItem[] = SETTINGS_KINDS.map((kind) => ({ value: kind, label: kindLabel(kind), description: entryDescription(kind, entryView(config, kind)) }));
     items.push({ value: "close", label: "Close" });
     const choice = await pick(ctx, "bot-lobby settings", items);
     if (!choice || choice === "close") return;
-    await editAgent(pi, ctx, choice as AgentKind);
+    await editEntry(pi, ctx, choice as SettingsKind);
   }
 }