@a-t-h-i/bot-lobby 0.6.38 → 0.6.40

package/src/schemas/configuration.ts

@@ -38,6 +38,8 @@ export interface ScoutConfig {
   mcpTools?: string[];
   model: ModelRef;
   timeoutMs: number;
+  /** Tool calls a scout may make: it is told to wrap up at 60% and refused more past this, so it reports with what it has; 0 = no limit. */
+  maxToolCalls: number;
 }
 
 /** Subagent kinds with their own settings entry. */
@@ -91,6 +93,10 @@ export interface WorkflowConfig {
   routeQuickFixes: boolean;
   /** A new task gets a git branch or worktree of its own, named after it; `--branch` and `--worktree` decide for one task. */
   gitIsolation: GitIsolation;
+  /** Scouts, workers, quick fixes and the planner get the repository map: the layout and the files matching their step, with each file's purpose, names and unchanged scout notes. */
+  repoMap: boolean;
+  /** A scout asked the same thing again for the same task, on a tree that has not changed, reuses its findings instead of running. */
+  reuseScouts: boolean;
 }
 
 /**
@@ -206,9 +212,15 @@ export interface ClassifierThresholds {
   quickFixLargeAt: number;
 }
 
-/** The Jev classifier: a fast model for obvious decisions, so large models spend fewer tokens on them. */
+/** The classifier: a fast model for obvious decisions, so large models spend fewer tokens on them. */
 export interface ClassifierConfig {
   enabled: boolean;
+  /**
+   * The model that answers, as `provider/id`: any classifier model pi lists
+   * (Jev, Cloudflare's clef, Liquid's d1, …) or any chat model you are signed
+   * in to (OpenAI, Anthropic, Google, …). Empty calls Jev on `provider`.
+   */
+  engine: string;
   /** Where Jev is called; the key comes from pi's own key store for that host. */
   provider: JevHostName;
   /** A pinned Jev model; empty uses the host's default. */
@@ -250,7 +262,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     backend: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "", timeoutMs: 15 * 60 * 1000 },
     qa: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "", timeoutMs: 15 * 60 * 1000 },
   },
-  scout: { model: INHERIT_MODEL, timeoutMs: 8 * 60 * 1000 },
+  scout: { model: INHERIT_MODEL, timeoutMs: 8 * 60 * 1000, maxToolCalls: 30 },
   researcher: { model: INHERIT_MODEL, thinking: "low", instructions: "", timeoutMs: 10 * 60 * 1000 },
   quickFix: { model: INHERIT_MODEL, thinking: "low", instructions: "", timeoutMs: 10 * 60 * 1000 },
   planner: { model: INHERIT_MODEL, thinking: "high", instructions: "", timeoutMs: 5 * 60 * 1000 },
@@ -272,6 +284,8 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     briefCheck: true,
     routeQuickFixes: true,
     gitIsolation: "off",
+    repoMap: true,
+    reuseScouts: true,
   },
   lint: { mode: "advise", command: "", extensions: [], timeoutMs: 2 * 60 * 1000 },
   knowledge: {
@@ -292,6 +306,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
   },
   classifier: {
     enabled: false,
+    engine: "",
     provider: "auto",
     model: "",
     baseUrl: "",
@@ -346,6 +361,7 @@ function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig
   return {
     model: typeof override?.model === "string" && override.model.trim() ? override.model : base.model,
     timeoutMs: positive(override?.timeoutMs) ?? base.timeoutMs,
+    maxToolCalls: typeof override?.maxToolCalls === "number" && Number.isFinite(override.maxToolCalls) && override.maxToolCalls >= 0 ? Math.round(override.maxToolCalls) : base.maxToolCalls,
     ...(mcpTools.length ? { mcpTools } : {}),
   };
 }
@@ -432,6 +448,7 @@ function normalizeClassifier(value: unknown): ClassifierConfig {
   const provider = typeof source.provider === "string" && (JEV_HOSTS as readonly string[]).includes(source.provider) ? source.provider as JevHostName : defaults.provider;
   return {
     enabled: flag(source.enabled, defaults.enabled),
+    engine: text(source.engine, defaults.engine).trim(),
     provider,
     model: text(source.model, defaults.model),
     baseUrl: text(source.baseUrl, defaults.baseUrl),
@@ -456,6 +473,8 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
   workflow.fastTrack = workflow.fastTrack !== false;
   workflow.briefCheck = workflow.briefCheck !== false;
   workflow.routeQuickFixes = workflow.routeQuickFixes !== false;
+  workflow.repoMap = workflow.repoMap !== false;
+  workflow.reuseScouts = workflow.reuseScouts !== false;
   workflow.gitIsolation = isGitIsolation(workflow.gitIsolation) ? workflow.gitIsolation : DEFAULT_CONFIG.workflow.gitIsolation;
   workflow.taskBudgetMinutes = typeof workflow.taskBudgetMinutes === "number" && workflow.taskBudgetMinutes > 0 ? Math.min(24 * 60, Math.round(workflow.taskBudgetMinutes)) : 0;
   const knowledge = { ...DEFAULT_CONFIG.knowledge, ...(src.knowledge as Partial<KnowledgeConfig> | undefined) };

package/src/schemas/findings.ts

@@ -3,6 +3,8 @@ import type { Blocker, Verdict } from "./task.ts";
 
 export interface RelevantFile {
   path: string;
+  /** The lines that matter (`42` or `12-40`), when the scout gave them as `path:12-40`. */
+  lines?: string;
   reason: string;
 }
 

package/src/state/work-time.ts

@@ -16,6 +16,8 @@ import { taskDirFor } from "./persistence.ts";
 export interface ActiveRun {
   runId: string;
   parentRunId?: string;
+  /** The worker's domain (`backend`, `designer`), for who is doing what. */
+  domain?: string;
   stepInstruction?: string;
   instruction: string;
   startedAt: string;
@@ -104,7 +106,7 @@ export function taskWork(root: string, configDir: string, taskId: string, now =
 const noted = new Map<string, Set<string>>();
 
 /** A worker run of the task started or ended: the steps it works on read as active while it runs. */
-export function noteWorkerRun(root: string, configDir: string, taskId: string, run: { runId: string; parentRunId?: string; stepInstruction?: string; instruction?: string; startedAt: string; status: string }): void {
+export function noteWorkerRun(root: string, configDir: string, taskId: string, run: { runId: string; parentRunId?: string; stepInstruction?: string; instruction?: string; domain?: string; startedAt: string; status: string }): void {
   const running = run.status === "running";
   const ids = noted.get(taskId) ?? new Set<string>();
   if (running === ids.has(run.runId)) return;
@@ -113,7 +115,7 @@ export function noteWorkerRun(root: string, configDir: string, taskId: string, r
   noted.set(taskId, ids);
   updateWork(root, configDir, taskId, (work) => {
     work.active = work.active.filter((entry) => entry.runId !== run.runId);
-    if (running) work.active.push({ runId: run.runId, instruction: run.instruction ?? "", startedAt: run.startedAt, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), ...(run.stepInstruction ? { stepInstruction: run.stepInstruction } : {}) });
+    if (running) work.active.push({ runId: run.runId, instruction: run.instruction ?? "", startedAt: run.startedAt, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), ...(run.domain ? { domain: run.domain } : {}), ...(run.stepInstruction ? { stepInstruction: run.stepInstruction } : {}) });
   });
 }
 

package/src/webui/api/plan-facts.ts

@@ -30,7 +30,7 @@ function activeRuns(task: Task, work: WorkProjection | undefined): AgentRun[] {
   const finished = new Set((task.workerRuns ?? []).map((record) => record.runId));
   return (work?.active ?? [])
     .filter((run) => !finished.has(run.runId))
-    .map((run) => ({ runId: run.runId, parentRunId: run.parentRunId, stepInstruction: run.stepInstruction, taskId: task.id, domain: "backend" as const, role: "worker" as const, status: "running" as const, instruction: run.instruction, output: "", attempts: 1, startedAt: run.startedAt }));
+    .map((run) => ({ runId: run.runId, parentRunId: run.parentRunId, stepInstruction: run.stepInstruction, taskId: task.id, domain: (run.domain === "designer" || run.domain === "qa" ? run.domain : "backend") as AgentRun["domain"], role: "worker" as const, status: "running" as const, instruction: run.instruction, output: "", attempts: 1, startedAt: run.startedAt }));
 }
 
 /** One step as the lobby shows it: its state, and while a worker is on it, how long they have worked on it. */
@@ -40,10 +40,20 @@ export interface StepView {
   active: boolean;
   activeAgentCount: number;
   runIds: string[];
+  /** The agents on it right now: who, doing what, since when; a child names its parent. */
+  agents: StepAgent[];
   /** Worker time on the step, in ms. */
   workedMs: number;
 }
 
+export interface StepAgent {
+  runId: string;
+  parentRunId?: string;
+  domain: string;
+  instruction: string;
+  startedAt: string;
+}
+
 /**
  * The plan's steps with their state, which ones a worker is on right now and
  * the worker time on each. A step being worked on is never done, so steps run
@@ -54,8 +64,13 @@ export function stepViews(task: Task, work: WorkProjection | undefined, now = Da
   const runs = [...persistedTaskRuns(task), ...activeRuns(task, work)];
   const checklist = planChecklist(task.plan, runs);
   const times = stepWork(planSteps(task.plan), runs, now);
+  const byId = new Map(runs.map((run) => [run.runId, run]));
   return checklist.map((step, index) => {
     const time = times[index] ?? { ms: 0, active: false, activeAgentCount: 0, runIds: [] };
-    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, runIds: time.runIds, workedMs: Math.round(time.ms) };
+    const agents = time.runIds.flatMap((runId) => {
+      const run = byId.get(runId);
+      return run ? [{ runId, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), domain: run.domain, instruction: (run.instruction ?? "").split("\n")[0]!.trim(), startedAt: run.startedAt }] : [];
+    });
+    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, runIds: time.runIds, agents, workedMs: Math.round(time.ms) };
   });
 }

package/src/webui/api/settings.ts

@@ -90,7 +90,8 @@ export function settingsGet(ctx: ApiContext): SettingsInfo {
     config = prefilled.config;
     pushNotice(`${prefilled.filled.map(kindLabel).join(", ")} now run on the session model; change them here any time.`);
   }
-  return { config: stripSecrets(config), models: ctx.service.models?.() ?? [] };
+  const classifiers = ctx.service.classifierModels?.() ?? [];
+  return { config: stripSecrets(config), models: ctx.service.models?.() ?? [], ...(classifiers.length > 0 ? { classifierModels: classifiers } : {}) };
 }
 
 /** The linters the project configures (its top and a few folders below), and whether each is installed. */

package/src/webui/api/tasks.ts

@@ -311,7 +311,7 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
     steps: stepViews(found, work, now).map((step) => ({
       text: step.text,
       status: step.status === "pending" ? "open" : step.status,
-      ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount } : {}),
+      ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount, agents: step.agents } : {}),
     })),
     amendments: [...found.amendments],
     waiting: waitingOf(found),

package/src/webui/dev/fake-service.ts

@@ -455,6 +455,7 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     },
     configChanged: () => {},
     models: () => models.map((model) => ({ id: model.id, label: model.label, thinkingLevels: [...model.thinkingLevels] })),
+    classifierModels: () => [{ id: "opencode/jev-1.13-free", label: "Jev 1.13 (free)" }, { id: "openrouter/liquid/d1", label: "Liquid D1" }],
     issuesEnabled: () => fixture.status.issuesEnabled,
     workspace: () => ({ ...fixture.status.workspace }),
     zen: () => ({ ...(fixture.zen.task ? { task: { ...fixture.zen.task } } : {}), runs: [...fixture.zen.runs] }),

package/src/webui/protocol.ts

@@ -200,6 +200,14 @@ export interface SettingsLinter {
 export interface SettingsInfo {
   config: BotLobbyConfig;
   models: SettingsModelInfo[];
+  /** Classifier models pi can call with the logins it holds (Jev on each host, Cloudflare's clef, Liquid's d1, …). */
+  classifierModels?: SettingsClassifierModel[];
+}
+
+/** A classifier model for the classifier's picker: `provider/id` and its name. */
+export interface SettingsClassifierModel {
+  id: string;
+  label: string;
 }
 
 /** One message on the event stream (`GET /api/events`, server-sent events). */
@@ -420,7 +428,7 @@ export interface TaskDetail {
    * The plan as a checklist, in order; `current` is the step under way, `active` the steps a worker is on right now,
    * each with its worker time (ms, as of the reply).
    */
-  steps: Array<{ text: string; status: "done" | "current" | "open"; active?: boolean; workedMs?: number; activeAgentCount?: number }>;
+  steps: Array<{ text: string; status: "done" | "current" | "open"; active?: boolean; workedMs?: number; activeAgentCount?: number; agents?: StepAgentInfo[] }>;
   /** How long the task's agents have worked on it, idle time left out (ms, as of the reply); `running` while they work. */
   work?: WorkClock;
   amendments: string[];
@@ -676,3 +684,12 @@ export interface Api {
 }
 
 export type ApiName = keyof Api;
+
+/** An agent on a step right now: its domain, what it was told (first line), since when; a child names its parent. */
+export interface StepAgentInfo {
+  runId: string;
+  parentRunId?: string;
+  domain: string;
+  instruction: string;
+  startedAt: string;
+}

package/src/workflow/workflow.ts

@@ -32,7 +32,7 @@ import { mapConcurrent } from "../execution/agent-runner.ts";
 import { parseWorkerResult } from "../roles/worker.ts";
 import { autoNote, DESK_TOOLS, DeskSession } from "../desk/session.ts";
 import type { Handover } from "../desk/desk.ts";
-import { changedFiles, commitBefore, headCommit, readRepositoryDiff } from "../execution/git.ts";
+import { changedFiles, commitBefore, commitFiles, commitMessage, headCommit, readRepositoryDiff, uncommitted } from "../execution/git.ts";
 import { appendChange, explainChanges, provenanceLines, provenanceSummary, readChanges, type FileProvenance } from "../state/changes.ts";
 import { budgetLine, budgetState, formatMinutes, MIN_READ_MS, parseMinutes, qaAllotment, readBudget, readerAllotment, updateBudget, workerAllotment, type Allotment, type BudgetState, type TaskBudget } from "../state/budget.ts";
 import type { AgentTime } from "../execution/agent-runner.ts";
@@ -141,6 +141,8 @@ export interface OrchestrateParams {
   note?: string;
   reason?: string;
   text?: string;
+  /** complete: the commit message for the agents' changes. */
+  message?: string;
   /** track: the path the task takes. */
   track?: "fast" | "full";
   /** track: who takes part (designer, backend, qa, researcher). */
@@ -1570,6 +1572,7 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   // The gate refuses before any side effect, so a refusal leaves the task untouched.
   const oversized = overThreshold(readDataRoots(deps.root, deps.configDir), deps.config.knowledge.compactionThreshold);
   if (oversized.length > 0) throw new Error(`cannot complete: knowledge files over the compaction threshold: ${oversized.map((entry) => `${entry.agent}/${entry.file} (${entry.chars})`).join(", ")}. First record domain-relevant facts where they belong with action=knowledge (domain=designer|backend|qa), then rewrite each oversized file with action=compact, then call complete again.`);
+  const committed = await commitTaskWork(task, params, deps);
   const summary = params.text?.trim() || task.proposal || task.title;
   recordCompletion(deps, task, summary);
   removeTaskScratchpads(deps.root, deps.configDir, task.id);
@@ -1581,7 +1584,43 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   flushDecisions(deps, task);
   const delivery = await offerDelivery(task, deps);
   const left = lint?.state === "failing" ? ` ${task.lintWaiver ? "Accepted by the user with lint errors" : "Lint (advisory)"}: ${lintSummary(lint)} Tell the user.` : "";
-  return `Task ${task.id} completed. History recorded and temporary scratchpads removed. ${delivery}${left}`;
+  return `Task ${task.id} completed.${committed} History recorded and temporary scratchpads removed. ${delivery}${left}`;
+}
+
+/** The files a task's own workers changed: not one that held changes before they started, nor another task's. */
+function agentsWork(files: readonly FileProvenance[]): string[] {
+  return files.filter((file) => file.kinds.includes("planned") && !file.kinds.includes("pre-existing") && !file.kinds.includes("other-task")).map((file) => file.path);
+}
+
+/**
+ * The oracle commits what its agents changed before the task is called done,
+ * with its own short message (`message`); nothing else in the tree is
+ * staged or committed. "" when git is not in use or nothing is left to commit.
+ */
+async function commitTaskWork(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
+  const state = await changeState(deps, task, await reviewBase(task, deps));
+  if (!state) return "";
+  const ours = agentsWork(state.files);
+  const dirty = await uncommitted(state.top, ours).catch(() => []);
+  if (dirty.length === 0) return "";
+  const listed = dirty.slice(0, 20).join(", ") + (dirty.length > 20 ? ` and ${dirty.length - 20} more` : "");
+  if (!params.message?.trim()) throw new Error(`cannot complete: commit the agents' changes first. Call complete again with message: a concise commit message for them (a first line of 72 characters or fewer saying what changed, at most three short lines below it). The engine commits only these files: ${listed}`);
+  let message: string;
+  try {
+    message = commitMessage(params.message);
+  } catch (error) {
+    throw new Error(`cannot complete: ${(error as Error).message}`);
+  }
+  let result: Awaited<ReturnType<typeof commitFiles>>;
+  try {
+    result = await commitFiles(state.top, dirty, message);
+  } catch (error) {
+    throw new Error(`cannot complete: git refused the commit: ${(error as Error).message}`);
+  }
+  if (!result) return "";
+  const others = await uncommitted(state.top, state.files.map((file) => file.path).filter((path) => !ours.includes(path))).catch(() => []);
+  const left = others.length > 0 ? ` Left uncommitted, not this task's agents' work: ${others.slice(0, 10).join(", ")}${others.length > 10 ? ` and ${others.length - 10} more` : ""}.` : "";
+  return ` Committed ${result.files.length} file${result.files.length === 1 ? "" : "s"} as ${result.commit.slice(0, 7)}: "${message.split("\n")[0]}".${left}`;
 }
 
 /** Completion always offers delivery to the user, including in auto mode. */