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

package/src/pi/settings-ui.ts

@@ -6,47 +6,75 @@ 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;
+  if (kind === "quickfix") return config.quickFix;
+  if (kind === "planner") return config.planner;
+  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 if (kind === "quickfix") next.quickFix = { ...config.quickFix, ...patch } as AgentModelConfig;
+  else if (kind === "planner") next.planner = { ...config.planner, ...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 +201,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 +219,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 +344,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);
   }
 }

package/src/pi/start-task.ts

@@ -0,0 +1,63 @@
+/**
+ * Starting a bot-lobby task in the current session, shared by
+ * `/bot-lobby <request>`, the lobby's prompt and pending tasks saved from the
+ * planner.
+ */
+import { existsSync } from "node:fs";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { createTask, taskRequest, type Task } from "../schemas/task.ts";
+import { createTaskDir, ensureProjectStructure, nextTaskId, ownedTask, saveTask, taskDirFor } from "../state/persistence.ts";
+import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { transition } from "../state/task-state.ts";
+import { shortTitle } from "../text.ts";
+import { applyStatus } from "./ui.ts";
+import { applyMasterModel } from "./settings-ui.ts";
+
+function uniqueTaskId(root: string, configDir: string, request: string): string {
+  const base = nextTaskId(request);
+  let id = base;
+  let suffix = 2;
+  while (existsSync(taskDirFor(root, configDir, id))) id = `${base}-${suffix++}`;
+  return id;
+}
+
+export function kickoff(task: Task): string {
+  return [
+    `A bot-lobby task is active: ${task.id}`,
+    `Title: ${task.title}`,
+    `Request: ${taskRequest(task)}`,
+    `State: ${task.state}`,
+    "",
+    "Drive it with the orchestrate tool:",
+    "1. clarify if the request is genuinely ambiguous,",
+    "2. scout the domains the request touches,",
+    "3. synthesize the findings and propose a short `- ` bullet list for approval.",
+    "Do not implement anything before the user approves the proposal.",
+  ].join("\n");
+}
+
+/**
+ * Create the task, hand it to this session's Master and send the kickoff.
+ * Returns the task, or undefined (with a warning) when this session already
+ * owns an active one.
+ */
+export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, request: string): Promise<Task | undefined> {
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  ensureProjectStructure(root, configDir);
+  const sessionId = ctx.sessionManager.getSessionId();
+  const existing = ownedTask(root, configDir, sessionId);
+  if (existing) {
+    ctx.ui.notify(`bot-lobby ${existing.id} is already active in this session. Finish it or run /bot-lobby cancel ${existing.id} first.`, "warning");
+    return undefined;
+  }
+  const task = createTask(uniqueTaskId(root, configDir, request), shortTitle(request), new Date().toISOString(), request, sessionId);
+  createTaskDir(root, configDir, task);
+  transition(task, "clarifying");
+  saveTask(root, configDir, task);
+  applyStatus(ctx, root, configDir);
+  await applyMasterModel(pi, ctx, loadConfig());
+  ctx.ui.notify(`bot-lobby ${task.id} started`, "info");
+  // A kickoff while pi is still busy (another turn) queues behind it instead of throwing.
+  pi.sendUserMessage(kickoff(task), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  return task;
+}

package/src/pi/tools.ts

@@ -4,11 +4,12 @@ import { Container, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { ProcessRunner } from "../execution/pi-runner.ts";
-import { inheritThinking } from "../schemas/configuration.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
 import { isQuiet } from "./quiet.ts";
+import { createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
+import { agentName, describeRun } from "./run-summary.ts";
 import {
   ORCHESTRATE_ACTIONS,
   runWorkflowAction,
@@ -26,9 +27,18 @@ const OrchestrateSchema = Type.Object({
   instruction: Type.Optional(Type.String({ description: "scout/research: what to investigate (for scout, also used to target-verify a claim)" })),
   proposal: Type.Optional(Type.String({ description: "propose: the user-facing proposal as a short `- ` bullet list, one line per change" })),
   concerns: Type.Optional(Type.Array(Type.String(), { description: "propose: concerns raised while challenging the request" })),
-  plan: Type.Optional(Type.String({ description: "plan: the detailed internal plan" })),
+  plan: Type.Optional(Type.String({ description: "plan: the detailed internal plan (while implementing or reviewing, the full revised plan that replaces it)" })),
   domain: Type.Optional(Type.String({ description: "implement/research: designer, backend, or qa" })),
   task: Type.Optional(Type.String({ description: "implement: the concrete step for that domain's worker" })),
+  assignments: Type.Optional(
+    Type.Array(
+      Type.Object({
+        domain: Type.String({ description: "designer, backend, or qa" }),
+        task: Type.String({ description: "the concrete step(s) for that domain's worker" }),
+      }),
+      { description: "implement: run several domains in parallel (distinct domains); workers share files through the file desk" },
+    ),
+  ),
   approvalId: Type.Optional(Type.String({ description: "resolve_approval: the approval id from a worker result" })),
   decision: Type.Optional(
     StringEnum(["approved", "rejected"] as const, { description: "resolve_approval: approve or reject the request" }),
@@ -49,7 +59,7 @@ const DESCRIPTION = [
   "Actions: clarify (ask the user), scout (domain reconnaissance in parallel), research (summon the",
   "read-only researcher for cited internet evidence on a complex change, tool, plugin, doc set or",
   "dependency), propose (record the proposal and request approval), plan (record the internal",
-  "plan), implement (delegate one step to a domain worker), qa (final quality gate and the only",
+  "plan, or amend it later with the full revised plan), implement (delegate a step to a domain worker, or several domains in parallel with assignments), qa (final quality gate and the only",
   "review), knowledge (record approved knowledge or a decision),",
   "compact (replace a knowledge file with a rewritten version, archiving the old one),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
@@ -57,22 +67,39 @@ const DESCRIPTION = [
   "The engine validates every step against the task state machine, so a rejected action means the workflow is not at that step yet.",
 ].join(" ");
 
-/** Build the engine dependencies from the current Pi context. `thinking` is the live session level used by agents configured to inherit it. */
+/** Resolve a `provider/id` (or bare id) against the models this session knows. */
+export function modelLookup(ctx: ExtensionContext): ModelLookup {
+  return (ref) => {
+    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);
+  };
+}
+
+/** Build the engine dependencies from the current Pi context; every agent's model and thinking come from settings. */
 export function workflowDeps(
   ctx: ExtensionContext,
   configDir: string,
   signal: AbortSignal | undefined,
   onUpdate: ((run: AgentRun) => void) | undefined,
   runProcess?: ProcessRunner,
-  thinking?: string,
 ): WorkflowDeps {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const hasUI = ctx.hasUI;
+  const config = loadConfig();
+  const warn = (message: string) => {
+    if (hasUI) ctx.ui.notify(message, "warning");
+  };
   return {
     root,
     configDir,
     cwd: ctx.cwd,
-    config: inheritThinking(loadConfig(), thinking),
+    config,
+    profile: createProfileResolver(config, {
+      lookup: modelLookup(ctx),
+      sessionModel: ctx.model ? modelRef(ctx.model) : undefined,
+      warn,
+    }),
     sessionId: ctx.sessionManager.getSessionId(),
     signal,
     onUpdate,
@@ -106,13 +133,28 @@ function runReporter(
 /** TUI-only transcript entries; these never enter the model's context. */
 function registerBotLobbyEntries(pi: ExtensionAPI): void {
   pi.registerEntryRenderer("bot-lobby", (entry, { expanded }, theme) => {
-    const data = entry.data as { kind?: string; taskId?: string; text?: string } | undefined;
+    const data = entry.data as { kind?: string; taskId?: string; text?: string; ok?: boolean } | undefined;
+    if (data?.kind === "run") {
+      // One compact line per finished subagent run.
+      return new Text(theme.fg(data.ok ? "dim" : "warning", data.text ?? ""), 0, 0);
+    }
     const header = `bot-lobby ${data?.taskId ?? ""} — ${data?.kind ?? "note"}`.trim();
     const body = data?.text ?? "";
     return new Text(`${theme.fg("accent", theme.bold(header))}\n${theme.fg("toolOutput", expanded ? body : truncate(body, 600))}`, 0, 0);
   });
 }
 
+/** A transcript line per finished run, plus a warning for anything that stalled or ran out of time. */
+function reportFinishedRuns(pi: ExtensionAPI, ctx: ExtensionContext, result: WorkflowResult): void {
+  for (const run of result.runs ?? []) {
+    const ok = run.status === "success" && !run.wrappedUp;
+    pi.appendEntry("bot-lobby", { kind: "run", taskId: result.taskId, text: describeRun(run), ok });
+    if (!ctx.hasUI) continue;
+    if (run.stalled) ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} stalled — ${run.error ?? "no output"}`, "warning");
+    else if (run.status === "timeout") ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} ${run.error ?? "hit its time limit"}`, "warning");
+  }
+}
+
 export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, runProcess?: ProcessRunner): void {
   registerBotLobbyEntries(pi);
   pi.registerTool({
@@ -128,11 +170,12 @@ export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, run
     renderShell: "self",
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const root = detectProjectRoot(ctx.cwd, configDir);
-      const deps = workflowDeps(ctx, configDir, signal, runReporter(onUpdate, (runs) => reportRuns(ctx, root, configDir, runs)), runProcess, pi.getThinkingLevel());
+      const deps = workflowDeps(ctx, configDir, signal, runReporter(onUpdate, (runs) => reportRuns(ctx, root, configDir, runs)), runProcess);
       const result = await runWorkflowAction(params as OrchestrateParams, deps);
       if (params.action === "propose" && params.proposal && result.ok) {
         pi.appendEntry("bot-lobby", { kind: "proposal", taskId: params.taskId, text: params.proposal });
       }
+      reportFinishedRuns(pi, ctx, result);
       applyStatus(ctx, root, configDir);
       return {
         content: [{ type: "text", text: result.message }],