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

package/src/schemas/configuration.ts

@@ -1,13 +1,24 @@
+import type { Domain, Role } from "./agent.ts";
+
 export type ModelRef = "inherit" | string;
 
 /** Thinking levels accepted by the pi CLI (`--thinking`). */
 export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 export type ThinkingLevelName = (typeof THINKING_LEVELS)[number];
 
-/** Value meaning "use the model/thinking of the current session". */
+/**
+ * A model value meaning "not configured". The master keeps the live session;
+ * a subagent falls back to the session's model until settings pin one.
+ * Thinking never inherits: every agent runs at the level its settings name.
+ */
 const INHERIT = "inherit";
 export const INHERIT_MODEL = INHERIT;
+/** Legacy thinking sentinel; configs that still carry it migrate to `DEFAULT_THINKING`. */
 export const INHERIT_THINKING = INHERIT;
+/** Level used for a missing, legacy `inherit` or unknown thinking value. */
+export const DEFAULT_THINKING: ThinkingLevelName = "medium";
+/** Scouts are reconnaissance: always fast, never configurable. */
+export const SCOUT_THINKING: ThinkingLevelName = "low";
 
 export function isThinkingLevel(value: string): value is ThinkingLevelName {
   return (THINKING_LEVELS as readonly string[]).includes(value);
@@ -18,8 +29,20 @@ export interface AgentModelConfig {
   thinking: string;
   /** Free-form instructions layered on top of this agent's built-in prompt. */
   instructions?: string;
+  /** Time limit per run; falls back to `workflow.agentTimeoutMs`. */
+  timeoutMs?: number;
+}
+
+/** Scouts pick a model and a time limit only; their thinking is fixed at `SCOUT_THINKING`. */
+export interface ScoutConfig {
+  model: ModelRef;
+  timeoutMs: number;
 }
 
+/** Subagent kinds with their own settings entry. */
+export const SUBAGENT_KINDS = ["designer", "backend", "qa", "scout", "researcher"] as const;
+export type SubagentKind = (typeof SUBAGENT_KINDS)[number];
+
 export interface WorkflowConfig {
   maxReviewIterations: number;
   maxParallelScouts: number;
@@ -27,8 +50,16 @@ export interface WorkflowConfig {
   requireApprovalForDependencies: boolean;
   requireApprovalForArchitectureChanges: boolean;
   agentTimeoutMs: number;
-  /** Bounded retries for transient agent failures (crash/timeout), §59. */
+  /** Bounded retries for transient agent failures (crash/stall), §59. A spent deadline never retries. */
   maxAgentRetries: number;
+  /** Kill a subagent after this long without any output; 0 disables. */
+  stallTimeoutMs: number;
+  /** Silence allowed while a single tool call runs (tests, builds); 0 disables. */
+  toolStallTimeoutMs: number;
+  /** Fraction of the time limit at which an agent is asked to wrap up and report; 0 disables. */
+  wrapUpAt: number;
+  /** Workers that may run at once when the Master delegates several domains together. */
+  maxParallelWorkers: number;
 }
 
 export interface KnowledgeConfig {
@@ -41,6 +72,8 @@ export interface KnowledgeConfig {
 export interface BotLobbyConfig {
   master: AgentModelConfig;
   agents: Record<"designer" | "backend" | "qa", AgentModelConfig>;
+  scout: ScoutConfig;
+  researcher: AgentModelConfig;
   workflow: WorkflowConfig;
   knowledge: KnowledgeConfig;
 }
@@ -48,10 +81,12 @@ export interface BotLobbyConfig {
 export const DEFAULT_CONFIG: BotLobbyConfig = {
   master: { model: INHERIT_MODEL, thinking: "high", instructions: "" },
   agents: {
-    designer: { model: INHERIT_MODEL, thinking: INHERIT_THINKING, instructions: "" },
-    backend: { model: INHERIT_MODEL, thinking: INHERIT_THINKING, instructions: "" },
-    qa: { model: INHERIT_MODEL, thinking: INHERIT_THINKING, instructions: "" },
+    designer: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "", timeoutMs: 15 * 60 * 1000 },
+    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 },
+  researcher: { model: INHERIT_MODEL, thinking: "low", instructions: "", timeoutMs: 10 * 60 * 1000 },
   workflow: {
     maxReviewIterations: 2,
     maxParallelScouts: 3,
@@ -60,6 +95,10 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     requireApprovalForArchitectureChanges: true,
     agentTimeoutMs: 15 * 60 * 1000,
     maxAgentRetries: 1,
+    stallTimeoutMs: 5 * 60 * 1000,
+    toolStallTimeoutMs: 10 * 60 * 1000,
+    wrapUpAt: 0.75,
+    maxParallelWorkers: 3,
   },
   knowledge: {
     compactionThreshold: 20000,
@@ -69,23 +108,25 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
   },
 };
 
-/** Merge one agent's override over its default, dropping an invalid thinking level but keeping the inherit sentinel. */
+function positive(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+/** Merge one agent's override over its default; legacy `inherit` or unknown thinking falls back to the default level. */
 function normalizeAgent(base: AgentModelConfig, override: Partial<AgentModelConfig> | undefined): AgentModelConfig {
   const merged = { ...base, ...(override ?? {}) };
-  const thinking = merged.thinking === INHERIT_THINKING || isThinkingLevel(merged.thinking) ? merged.thinking : base.thinking;
-  return { ...merged, thinking };
+  const thinking = isThinkingLevel(merged.thinking) ? merged.thinking : base.thinking;
+  const timeoutMs = positive(merged.timeoutMs) ?? base.timeoutMs;
+  return { ...merged, thinking, ...(timeoutMs ? { timeoutMs } : {}) };
 }
 
-/** Replace every agent's inherit thinking with the live session level; a missing/invalid level omits the flag. */
-export function inheritThinking(config: BotLobbyConfig, level: string | undefined): BotLobbyConfig {
-  const resolved = level && isThinkingLevel(level) ? level : "";
-  const agents = Object.fromEntries(
-    Object.entries(config.agents).map(([name, agent]) => [
-      name,
-      agent.thinking === INHERIT_THINKING ? { ...agent, thinking: resolved } : { ...agent },
-    ]),
-  ) as BotLobbyConfig["agents"];
-  return { ...config, agents };
+/** Scouts keep a model and a time limit; any thinking value in the file is dropped. */
+function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig {
+  const base = DEFAULT_CONFIG.scout;
+  return {
+    model: typeof override?.model === "string" && override.model.trim() ? override.model : base.model,
+    timeoutMs: positive(override?.timeoutMs) ?? base.timeoutMs,
+  };
 }
 
 /** Deep-merge user config over defaults, keeping unknown keys out. */
@@ -101,7 +142,60 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
       backend: normalizeAgent(DEFAULT_CONFIG.agents.backend, srcAgents.backend),
       qa: normalizeAgent(DEFAULT_CONFIG.agents.qa, srcAgents.qa),
     },
+    scout: normalizeScout(src.scout as Partial<ScoutConfig> | undefined),
+    researcher: normalizeAgent(DEFAULT_CONFIG.researcher, src.researcher as Partial<AgentModelConfig> | undefined),
     workflow,
     knowledge,
   };
 }
+
+/** True when a config file still carries a thinking value for scouts, which is ignored. */
+export function hasScoutThinking(partial: unknown): boolean {
+  const scout = (partial as { scout?: Record<string, unknown> } | undefined)?.scout;
+  return Boolean(scout && typeof scout === "object" && "thinking" in scout);
+}
+
+/** What one subagent run uses: model (undefined = not configured), thinking and time limit. */
+export interface AgentProfile {
+  kind: SubagentKind;
+  model?: string;
+  thinking: string;
+  timeoutMs: number;
+  instructions?: string;
+}
+
+/** The settings entry a domain/role run draws from. */
+export function profileKind(domain: Domain, role: Role): SubagentKind {
+  if (role === "scout") return "scout";
+  if (role === "researcher") return "researcher";
+  return domain;
+}
+
+function modelOf(ref: ModelRef): string | undefined {
+  return ref === INHERIT_MODEL || !ref.trim() ? undefined : ref;
+}
+
+/**
+ * Resolve model, thinking and time limit for one run from settings alone.
+ * Workers and the QA gate use their domain's entry, scouts and researchers
+ * their own; custom instructions always come from the domain, so a designer
+ * scout still carries the designer's house rules.
+ */
+export function agentProfile(config: BotLobbyConfig, domain: Domain, role: Role): AgentProfile {
+  const kind = profileKind(domain, role);
+  const instructions = config.agents[domain].instructions;
+  const fallback = config.workflow.agentTimeoutMs;
+  if (kind === "scout") {
+    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions };
+  }
+  const entry = kind === "researcher" ? config.researcher : config.agents[kind];
+  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions };
+}
+
+/** Resolves the model, thinking and time limit one subagent run uses. */
+export type ProfileResolver = (domain: Domain, role: Role) => AgentProfile;
+
+/** The resolver a request carries, or plain settings when none was supplied (tests, headless use). */
+export function profileFor(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: Role): AgentProfile {
+  return resolver ? resolver(domain, role) : agentProfile(config, domain, role);
+}

package/src/schemas/findings.ts

@@ -67,6 +67,8 @@ export interface ReviewResult {
   requiredChanges: string[];
   optionalImprovements: string[];
   pushback?: Pushback;
+  /** Set when the engine downgraded an unsupported PASS. */
+  downgraded?: string;
   raw: string;
 }
 
@@ -107,4 +109,22 @@ export interface AgentRun {
   usage?: { input: number; output: number; cost: number; turns: number };
   startedAt: string;
   finishedAt?: string;
+  /** Short target of the activity in flight: a file, command head or pattern. */
+  detail?: string;
+  /** Assistant turns and tool calls so far. */
+  turns?: number;
+  tools?: number;
+  /** Epoch ms of the last streamed output; drives the "quiet" warning. */
+  lastEventAt?: number;
+  /** Transient status worth surfacing: retrying, compacting, wrapping up, waiting on a file. */
+  note?: string;
+  noteKind?: "info" | "warning";
+  /** Model that actually served the run. */
+  model?: string;
+  /** Killed by the stall watchdog after going silent. */
+  stalled?: boolean;
+  /** Asked to wrap up before its deadline; the report may be partial. */
+  wrappedUp?: boolean;
+  /** File this worker is queued for at the file desk. */
+  waitingFor?: string;
 }

package/src/schemas/task.ts

@@ -1,4 +1,4 @@
-import type { Domain } from "./agent.ts";
+import type { Domain, Role } from "./agent.ts";
 
 export const TASK_STATES = [
   "created",
@@ -70,6 +70,29 @@ export interface WorkerRunRecord {
 /** Upper bound on persisted worker records; plans cap at 50 steps. */
 export const MAX_WORKER_RECORDS = 64;
 
+/** One finished subagent run of any role, kept for `/bot-lobby runs`. */
+export interface RunLogEntry {
+  runId: string;
+  domain: Domain;
+  role: Role;
+  status: "running" | "success" | "failed" | "cancelled" | "timeout";
+  startedAt: string;
+  finishedAt?: string;
+  model?: string;
+  turns?: number;
+  tools?: number;
+  input?: number;
+  output?: number;
+  cost?: number;
+  attempts?: number;
+  stalled?: boolean;
+  wrappedUp?: boolean;
+  error?: string;
+}
+
+/** Upper bound on persisted run-log entries. */
+export const MAX_RUN_LOG = 64;
+
 export interface Task {
   id: string;
   title: string;
@@ -89,6 +112,8 @@ export interface Task {
   approvals: Approval[];
   /** Worker delegations in start order; absent on tasks created before tracking. */
   workerRuns?: WorkerRunRecord[];
+  /** Recent finished runs of every role, newest last. */
+  runLog?: RunLogEntry[];
   createdAt: string;
   updatedAt: string;
   /** The pi session (ctx.sessionManager id) that owns this task; absent on legacy tasks. */

package/src/state/project.ts

@@ -80,6 +80,15 @@ function configSourcePath(): string {
   return candidates.find((path) => existsSync(path)) ?? candidates[0]!;
 }
 
+/** The config file as written, unresolved; undefined when missing or unreadable. */
+export function readRawConfig(): unknown {
+  try {
+    return JSON.parse(readFileSync(configSourcePath(), "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
 /** Load the global config; fall back to defaults on any read/parse error. */
 export function loadConfig(): BotLobbyConfig {
   try {

package/src/text.ts

@@ -49,3 +49,12 @@ export function shortTitle(request: string, maxWords = 3): string {
   const content = words.filter((word) => !FILLER_WORDS.has(fillerKey(word)));
   return (content.length > 0 ? content : words).slice(0, maxWords).join(" ");
 }
+
+/** Compact duration such as "45s", "3m" or "2m 05s"; a non-finite input reads "0s". */
+export function shortDuration(ms: number): string {
+  const seconds = Number.isFinite(ms) ? Math.max(0, Math.round(ms / 1000)) : 0;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes === 0) return `${seconds}s`;
+  const rest = seconds % 60;
+  return rest === 0 ? `${minutes}m` : `${minutes}m ${String(rest).padStart(2, "0")}s`;
+}

package/src/workflow/workflow.ts

@@ -1,7 +1,8 @@
 import { join } from "node:path";
-import type { BotLobbyConfig } from "../schemas/configuration.ts";
+import type { BotLobbyConfig, ProfileResolver } from "../schemas/configuration.ts";
 import type { AgentRun, Pushback, ResearchResult, ReviewResult } from "../schemas/findings.ts";
 import {
+  MAX_RUN_LOG,
   MAX_WORKER_RECORDS,
   TASK_STATES,
   TERMINAL_STATES,
@@ -21,6 +22,10 @@ import { compactKnowledgeFile, overThreshold } from "../knowledge/compactor.ts";
 import { knowledgeDir, type KnowledgeAgent } from "../knowledge/paths.ts";
 import { writeScratchpad } from "../state/persistence.ts";
 import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
+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 { readRepositoryDiff } from "../execution/git.ts";
 import {
   loadScoutResults,
@@ -39,6 +44,7 @@ import { detectSharedFiles, summarizeOutcomes } from "../master/synthesis.ts";
 import { truncate } from "../text.ts";
 import { assertNoPendingApprovals, pendingApprovals, requestApproval, resolveApproval } from "./approvals.ts";
 import { pingApproval } from "../pi/notify.ts";
+import { describeRun, runLogEntry } from "../pi/run-summary.ts";
 import { nextStates } from "./transitions.ts";
 
 export const ORCHESTRATE_ACTIONS = [
@@ -79,6 +85,8 @@ export interface OrchestrateParams {
   domain?: string;
   /** implement: the concrete instruction for the worker. */
   task?: string;
+  /** implement: several domains at once, run in parallel through the file desk. */
+  assignments?: Array<{ domain: string; task: string }>;
   /** knowledge: which persistent file the text belongs to. */
   kind?: KnowledgeKind;
   /** compact: the knowledge file being rewritten. */
@@ -97,6 +105,8 @@ export interface WorkflowDeps {
   /** The pi session driving this workflow; task ownership is skipped when absent (tests, headless use). */
   sessionId?: string;
   config: BotLobbyConfig;
+  /** Per-run model/thinking/time limit, clamped to each model; plain settings when absent. */
+  profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
   ask: (question: string) => Promise<string | undefined>;
@@ -110,6 +120,8 @@ export interface WorkflowResult {
   taskId: string;
   state: TaskState;
   message: string;
+  /** Subagent runs that finished during this action, oldest first. */
+  runs?: AgentRun[];
 }
 
 export type ApprovalChoice = "approve" | "amend" | "decline";
@@ -250,6 +262,7 @@ async function handleScout(task: Task, params: OrchestrateParams, deps: Workflow
       dataRoots: readDataRoots(deps.root, deps.configDir),
       taskDir: taskDirFor(deps.root, deps.configDir, task.id),
       config: deps.config,
+      profile: deps.profile,
       signal: deps.signal,
       onUpdate: deps.onUpdate,
     },
@@ -344,6 +357,7 @@ function researchRequestFor(
     domain,
     instruction,
     config: deps.config,
+    profile: deps.profile,
     cwd: deps.cwd,
     taskDir,
     signal: deps.signal,
@@ -500,6 +514,7 @@ function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instructi
     cwd: deps.cwd,
     dataRoots: readDataRoots(deps.root, deps.configDir),
     config: deps.config,
+    profile: deps.profile,
     signal: deps.signal,
     onUpdate: deps.onUpdate,
   };
@@ -518,15 +533,32 @@ function recordWorkerRun(task: Task, run: AgentRun): void {
   task.workerRuns = [...(task.workerRuns ?? []), record].slice(-MAX_WORKER_RECORDS);
 }
 
-async function handleImplement(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
-  requireState(task, ["planning", "implementing", "reviewing"]);
+interface Assignment {
+  domain: Domain;
+  instruction: string;
+}
+
+/** The delegation as a list: `assignments` for a parallel batch, otherwise the single domain/task. */
+function parseAssignments(params: OrchestrateParams): Assignment[] {
+  if (params.assignments && params.assignments.length > 0) {
+    const list = params.assignments.map((entry) => {
+      const instruction = entry.task?.trim();
+      if (!instruction) throw new Error("every assignment needs a task (what to implement)");
+      return { domain: parseDomain(entry.domain, "implement"), instruction };
+    });
+    const domains = list.map((entry) => entry.domain);
+    if (new Set(domains).size !== domains.length) throw new Error("parallel assignments need distinct domains (one worker per domain)");
+    return list;
+  }
   const domain = parseDomain(params.domain, "implement");
   const instruction = params.task?.trim();
   if (!instruction) throw new Error("implement requires task (what to implement)");
-  assertNoPendingApprovals(task, domain);
-  if (!task.domains.includes(domain)) task.domains.push(domain);
-  if (task.state !== "implementing") transition(task, "implementing");
-  const outcome = await runWorker(workerRequest(deps, task, domain, instruction), deps.runProcess ?? spawnPiProcess);
+  return [{ domain, instruction }];
+}
+
+/** Record one worker's outcome on the task and return its report for the Master. */
+function absorbWorkerOutcome(task: Task, deps: WorkflowDeps, outcome: WorkerOutcome): string {
+  const domain = outcome.result.domain;
   recordWorkerRun(task, outcome.run);
   const approvals = recordWorkerApprovals(task, outcome, deps.config);
   const pushback = recordPushback(task, outcome);
@@ -535,6 +567,67 @@ async function handleImplement(task: Task, params: OrchestrateParams, deps: Work
   return workerReport(outcome, approvals, pushback);
 }
 
+async function handleImplement(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
+  requireState(task, ["planning", "implementing", "reviewing"]);
+  const assignments = parseAssignments(params);
+  for (const { domain } of assignments) assertNoPendingApprovals(task, domain);
+  for (const { domain } of assignments) if (!task.domains.includes(domain)) task.domains.push(domain);
+  if (task.state !== "implementing") transition(task, "implementing");
+  if (assignments.length === 1) {
+    const { domain, instruction } = assignments[0]!;
+    const outcome = await runWorker(workerRequest(deps, task, domain, instruction), deps.runProcess ?? spawnPiProcess);
+    return absorbWorkerOutcome(task, deps, outcome);
+  }
+  return runParallelWorkers(task, deps, assignments);
+}
+
+/**
+ * Several domains at once. The workers share one file desk: each claims a file
+ * before editing it, queues for a busy one, and hands it over with a note; a
+ * worker that finishes hands over whatever it still holds automatically.
+ */
+async function runParallelWorkers(task: Task, deps: WorkflowDeps, assignments: Assignment[]): Promise<string> {
+  const session = new DeskSession({ cwd: deps.cwd });
+  await session.open();
+  let outcomes: WorkerOutcome[];
+  let unenforced: Domain[];
+  try {
+    outcomes = await mapConcurrent(assignments, deps.config.workflow.maxParallelWorkers, ({ domain, instruction }) => {
+      const request = workerRequest(deps, task, domain, instruction);
+      request.agent = {
+        env: session.env(domain),
+        extraTools: DESK_TOOLS,
+        onStart: (handle) => session.attach(domain, handle),
+        onAttemptEnd: (run) => {
+          const result = parseWorkerResult(domain, run.output);
+          session.release(domain, (path, next) => autoNote(domain, path, next, result.filesChanged, result.completed));
+        },
+      };
+      return runWorker(request, deps.runProcess ?? spawnPiProcess);
+    });
+    unenforced = assignments.map((entry) => entry.domain).filter((domain) => !session.greetedBy(domain));
+  } finally {
+    await session.close();
+  }
+  const reports = outcomes.map((outcome) => absorbWorkerOutcome(task, deps, outcome));
+  return [
+    `Parallel batch: ${assignments.map((entry) => entry.domain).join(", ")}.`,
+    ...reports,
+    handoverLog(session.handovers()),
+    unenforced.length > 0
+      ? `File checkout was not enforced for ${unenforced.join(", ")} (bot-lobby did not load in those workers); inspect the diff for overlapping edits.`
+      : "",
+  ]
+    .filter((line) => line.length > 0)
+    .join("\n\n");
+}
+
+function handoverLog(handovers: readonly Handover[]): string {
+  if (handovers.length === 0) return "";
+  const lines = handovers.map((entry) => `- ${entry.path}: ${entry.from} → ${entry.to}${entry.auto ? " (on finish)" : ""} — ${truncate(entry.note, 200)}`);
+  return `File handovers:\n${lines.join("\n")}`;
+}
+
 function handleResolveApproval(task: Task, params: OrchestrateParams): string {
   const id = params.approvalId?.trim();
   const decision = params.decision;
@@ -597,6 +690,7 @@ function qaRequest(deps: WorkflowDeps, task: Task, diff: string, instruction?: s
     cwd: deps.cwd,
     dataRoots: readDataRoots(deps.root, deps.configDir),
     config: deps.config,
+    profile: deps.profile,
     signal: deps.signal,
     onUpdate: deps.onUpdate,
   };
@@ -784,12 +878,35 @@ export async function runWorkflowAction(params: OrchestrateParams, deps: Workflo
   if (!handler) {
     return { ok: false, taskId: task.id, state: task.state, message: `Unknown action "${params.action}".` };
   }
+  const finished = new Map<string, AgentRun>();
+  const tracked: WorkflowDeps = {
+    ...deps,
+    onUpdate: (run) => {
+      if (run.status !== "running") finished.set(run.runId, run);
+      deps.onUpdate?.(run);
+    },
+  };
   try {
-    const message = await handler(task, params, deps);
+    const message = await handler(task, params, tracked);
+    const runs = recordRunLog(task, finished);
     saveTask(deps.root, deps.configDir, task);
-    return { ok: true, taskId: task.id, state: task.state, message };
+    return { ok: true, taskId: task.id, state: task.state, message: `${message}${runsFooter(runs)}`, runs };
   } catch (error) {
+    const runs = recordRunLog(task, finished);
     saveTask(deps.root, deps.configDir, task);
-    return { ok: false, taskId: task.id, state: task.state, message: `Rejected: ${(error as Error).message}` };
+    return { ok: false, taskId: task.id, state: task.state, message: `Rejected: ${(error as Error).message}`, runs };
   }
 }
+
+/** Append this action's finished runs to the task's bounded run log. */
+function recordRunLog(task: Task, finished: ReadonlyMap<string, AgentRun>): AgentRun[] {
+  const runs = [...finished.values()];
+  if (runs.length > 0) task.runLog = [...(task.runLog ?? []), ...runs.map(runLogEntry)].slice(-MAX_RUN_LOG);
+  return runs;
+}
+
+/** One line per run so the Master sees timing, model and any partial-report flag. */
+function runsFooter(runs: readonly AgentRun[]): string {
+  if (runs.length === 0) return "";
+  return `\n\nRuns:\n${runs.map((run) => `- ${describeRun(run)}`).join("\n")}`;
+}