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

package/src/master/master.ts

@@ -1,10 +1,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import type { BotLobbyConfig } from "../schemas/configuration.ts";
+import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
 import type { Domain } from "../schemas/agent.ts";
 import type { AgentRun, ReviewResult, ScoutResult, WorkerResult } from "../schemas/findings.ts";
 import { domainSpec } from "../agents/registry.ts";
-import { runAgent, runParallel, type AgentRequest } from "../execution/agent-runner.ts";
+import { runAgent, runParallel, watchdogOptions, type AgentRequest } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
 import { readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
 import { selectKnowledge, type KnowledgeSelection } from "../knowledge/selector.ts";
@@ -32,14 +32,16 @@ export interface ScoutRequest {
   dataRoots: readonly string[];
   taskDir: string;
   config: BotLobbyConfig;
+  /** Settings-derived model/thinking/time limit, clamped to the model; plain settings when absent. */
+  profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
 }
 
-/** Models are inherited from the session unless the config pins one. */
-export function resolveModel(config: BotLobbyConfig, domain: Domain): string | undefined {
-  const model = config.agents[domain].model;
-  return model === "inherit" ? undefined : model;
+/** Model, thinking and time limit for one run, from settings. */
+function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
+  const profile = profileFor(config, resolver, domain, role);
+  return { model: profile.model, thinking: profile.thinking, timeoutMs: profile.timeoutMs };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {
@@ -82,13 +84,11 @@ export async function runScouts(request: ScoutRequest, run: ProcessRunner = spaw
     role: "scout",
     instruction: scoutInstruction(request, domain),
     context: scoutContext(request, domain),
-    model: resolveModel(request.config, domain),
-    thinking: request.config.agents[domain].thinking,
-    timeoutMs: request.config.workflow.agentTimeoutMs,
+    ...profileFields(request.config, request.profile, domain, "scout"),
     cwd: request.cwd,
     signal: request.signal,
     onUpdate: request.onUpdate,
-    retries: request.config.workflow.maxAgentRetries,
+    ...watchdogOptions(request.config.workflow),
   }));
   const runs = await runParallel(requests, request.config.workflow.maxParallelScouts, run);
   const outcomes = runs.map((agentRun) => toOutcome(agentRun, agentRun.domain));
@@ -136,6 +136,8 @@ export interface WorkerOutcome {
 }
 
 export interface WorkerRequest {
+  /** Extra run wiring for parallel batches: the file desk's env, tools and hooks. */
+  agent?: Pick<AgentRequest, "env" | "extraTools" | "onStart" | "onAttemptEnd">;
   taskId: string;
   domain: Domain;
   /** What the Master wants implemented. */
@@ -146,6 +148,8 @@ export interface WorkerRequest {
   cwd: string;
   dataRoots: readonly string[];
   config: BotLobbyConfig;
+  /** Settings-derived model/thinking/time limit, clamped to the model; plain settings when absent. */
+  profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
 }
@@ -184,13 +188,12 @@ export async function runWorker(
         instructions: request.config.agents[request.domain].instructions,
         workflowContext: workerWorkflowContext(request),
       },
-      model: resolveModel(request.config, request.domain),
-      thinking: request.config.agents[request.domain].thinking,
-      timeoutMs: request.config.workflow.agentTimeoutMs,
+      ...profileFields(request.config, request.profile, request.domain, "worker"),
       cwd: request.cwd,
       signal: request.signal,
       onUpdate: request.onUpdate,
-      retries: request.config.workflow.maxAgentRetries,
+      ...watchdogOptions(request.config.workflow),
+      ...request.agent,
     },
     run,
   );
@@ -219,6 +222,8 @@ export interface ReviewerRequest {
   cwd: string;
   dataRoots: readonly string[];
   config: BotLobbyConfig;
+  /** Settings-derived model/thinking/time limit, clamped to the model; plain settings when absent. */
+  profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
 }
@@ -262,12 +267,11 @@ function reviewerAgentRequest(request: ReviewerRequest, selected: KnowledgeSelec
       instructions: request.config.agents[request.domain].instructions,
       workflowContext: reviewerContext(request),
     },
-    model: resolveModel(request.config, request.domain),
-    thinking: request.config.agents[request.domain].thinking,
-    timeoutMs: request.config.workflow.agentTimeoutMs,
+    ...profileFields(request.config, request.profile, request.domain, "reviewer"),
     cwd: request.cwd,
     signal: request.signal,
     onUpdate: request.onUpdate,
+    ...watchdogOptions(request.config.workflow),
     retries: 0,
   };
 }

package/src/master/research.ts

@@ -1,13 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Domain } from "../schemas/agent.ts";
-import type { BotLobbyConfig } from "../schemas/configuration.ts";
+import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
 import type { AgentRun, ResearchResult } from "../schemas/findings.ts";
-import { runAgent, type AgentRequest } from "../execution/agent-runner.ts";
+import { runAgent, watchdogOptions, type AgentRequest } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
 import { writeFileEnsured } from "../knowledge/store.ts";
 import { isResearchResultUsable, parseResearchResult, validateResearchResult } from "../roles/researcher.ts";
-import { resolveModel } from "./master.ts";
 
 export interface ResearchOutcome {
   result: ResearchResult;
@@ -25,6 +24,7 @@ export interface ResearchRequest {
   cwd: string;
   taskDir: string;
   config: BotLobbyConfig;
+  profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
 }
@@ -75,6 +75,7 @@ function toOutcome(run: AgentRun, domain: Domain): ResearchOutcome {
 
 /** Run the researcher for one domain and persist its report for audit. */
 export async function runResearch(request: ResearchRequest, run: ProcessRunner = spawnPiProcess): Promise<ResearchOutcome> {
+  const profile = profileFor(request.config, request.profile, request.domain, "researcher");
   const agentRun = await runAgent(
     {
       taskId: request.taskId,
@@ -82,13 +83,13 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       role: "researcher",
       instruction: request.instruction,
       context: researchContext(request),
-      model: resolveModel(request.config, request.domain),
-      thinking: request.config.agents[request.domain].thinking,
-      timeoutMs: request.config.workflow.agentTimeoutMs,
+      model: profile.model,
+      thinking: profile.thinking,
+      timeoutMs: profile.timeoutMs,
       cwd: request.cwd,
       signal: request.signal,
       onUpdate: request.onUpdate,
-      retries: request.config.workflow.maxAgentRetries,
+      ...watchdogOptions(request.config.workflow),
     },
     run,
   );

package/src/pi/activity.ts

@@ -61,3 +61,168 @@ export function oracleActivityWord(toolName: string, args?: unknown): string {
   const action = orchestrateAction(args);
   return (action && ORACLE_ACTION_WORDS[action]) || FALLBACK_WORD;
 }
+
+const DETAIL_CHARS = 28;
+
+function clip(text: string): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > DETAIL_CHARS ? `${flat.slice(0, DETAIL_CHARS - 1)}…` : flat;
+}
+
+function field(args: unknown, ...names: string[]): string | undefined {
+  if (!args || typeof args !== "object") return undefined;
+  for (const name of names) {
+    const value = (args as Record<string, unknown>)[name];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return undefined;
+}
+
+/** Last path segment, so `src/pi/zen.ts` reads `zen.ts`. */
+function baseName(path: string): string {
+  const parts = path.replace(/[\\/]+$/, "").split(/[\\/]/);
+  return parts.at(-1) || path;
+}
+
+/**
+ * A short target for what a tool call touches: the file for read/edit/write,
+ * the command head for bash, the pattern for grep, the query for web search.
+ * Pure; undefined when the arguments name nothing useful.
+ */
+export function activityDetail(toolName: string, args?: unknown): string | undefined {
+  const tool = toolName.trim().toLowerCase();
+  if (tool === "read" || tool === "edit" || tool === "write" || tool === "ls") {
+    const path = field(args, "path", "file_path", "file");
+    return path ? clip(baseName(path)) : undefined;
+  }
+  if (tool === "bash") {
+    const command = field(args, "command", "cmd");
+    return command ? clip(command) : undefined;
+  }
+  if (tool === "grep" || tool === "find") {
+    const pattern = field(args, "pattern", "query", "glob");
+    return pattern ? clip(`"${pattern}"`) : undefined;
+  }
+  const query = field(args, "query", "url", "path");
+  return query ? clip(query) : undefined;
+}
+
+const STEP_CHARS = 60;
+
+function clipTo(text: string, max: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
+/** `https://example.com/docs/page?q=1` reads `example.com/docs/page`. */
+function shortUrl(url: string): string {
+  return url.replace(/^[a-z]+:\/\//i, "").replace(/[?#].*$/, "").replace(/\/$/, "");
+}
+
+function list(value: unknown): string | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const items = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  return items.length > 0 ? items.join(", ") : undefined;
+}
+
+/** What the Master is doing with one `orchestrate` call, in words. */
+function orchestrateStep(args: unknown): string {
+  const action = orchestrateAction(args);
+  const text = (...names: string[]) => field(args, ...names);
+  switch (action) {
+    case "clarify":
+      return `asking you: ${clipTo(text("question") ?? "a question", STEP_CHARS)}`;
+    case "scout":
+      return `scouting ${list((args as { domains?: unknown }).domains) ?? "the codebase"}`;
+    case "research":
+      return `summoning research${text("instruction") ? ` on ${clipTo(text("instruction")!, STEP_CHARS - 20)}` : ""}`;
+    case "propose":
+      return "proposing the change for your approval";
+    case "plan":
+      return "writing the plan";
+    case "implement": {
+      const assignments = (args as { assignments?: Array<{ domain?: unknown }> }).assignments;
+      const domains = Array.isArray(assignments) ? list(assignments.map((entry) => entry?.domain)) : text("domain");
+      const task = text("task");
+      return `delegating to ${domains ?? "a worker"}${task ? `: ${clipTo(task, STEP_CHARS - 20)}` : ""}`;
+    }
+    case "qa":
+      return "running the QA gate";
+    case "knowledge":
+      return "recording knowledge";
+    case "compact":
+      return `compacting ${text("file") ?? "knowledge"}`;
+    case "resolve_approval":
+      return `${text("decision") === "rejected" ? "rejecting" : "approving"} ${text("approvalId") ?? "a request"}`;
+    case "complete":
+      return "wrapping up the task";
+    case "block":
+      return `blocking the task${text("reason") ? `: ${clipTo(text("reason")!, STEP_CHARS - 20)}` : ""}`;
+    case "resume":
+      return "resuming the task";
+    case "decide":
+      return "recording a decision";
+    case "status":
+      return "checking the task status";
+    case "cancel":
+      return "cancelling the task";
+    default:
+      return "orchestrating";
+  }
+}
+
+/**
+ * One plain-words line for a tool call, the way a person would narrate it:
+ * `reading index.html`, `searching for "router" in src`, `running npm test`,
+ * `delegating to backend: Step 2 …`. Pure; unknown tools read `using <name>`.
+ */
+export function describeToolCall(toolName: string, args?: unknown): string {
+  const tool = toolName.trim().toLowerCase();
+  const path = field(args, "path", "file_path", "file");
+  switch (tool) {
+    case "read":
+      return `reading ${path ? baseName(path) : "a file"}`;
+    case "edit":
+      return `editing ${path ? baseName(path) : "a file"}`;
+    case "write":
+      return `writing ${path ? baseName(path) : "a file"}`;
+    case "ls":
+      return `listing ${path ? clipTo(path, STEP_CHARS) : "the folder"}`;
+    case "grep": {
+      const pattern = field(args, "pattern", "query");
+      return `searching for ${pattern ? `"${clipTo(pattern, 40)}"` : "a pattern"}${path ? ` in ${baseName(path)}` : ""}`;
+    }
+    case "find": {
+      const pattern = field(args, "pattern", "glob", "query");
+      return `finding ${pattern ? clipTo(pattern, 40) : "files"}${path ? ` in ${baseName(path)}` : ""}`;
+    }
+    case "bash": {
+      const command = field(args, "command", "cmd");
+      return command ? `running ${clipTo(command, STEP_CHARS)}` : "running a command";
+    }
+    case "web_search":
+      return `searching the web for "${clipTo(field(args, "query") ?? "…", 48)}"`;
+    case "fetch_content":
+    case "web_fetch":
+    case "fetch": {
+      const url = field(args, "url");
+      return `fetching ${url ? clipTo(shortUrl(url), STEP_CHARS) : "a page"}`;
+    }
+    case "get_search_content":
+      return "reading search results";
+    case "source_check":
+      return "checking sources";
+    case "claim_file":
+      return `claiming ${path ? baseName(path) : "a file"}`;
+    case "handover_file":
+      return `handing over ${path ? baseName(path) : "a file"}`;
+    case "wait_for_files":
+      return "waiting for files";
+    case "my_files":
+      return "checking its files";
+    case "orchestrate":
+      return orchestrateStep(args);
+    default:
+      return `using ${toolName.trim() || "a tool"}`;
+  }
+}

package/src/pi/commands.ts

@@ -1,19 +1,15 @@
-import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { TERMINAL_STATES, createTask, taskRequest, type Task } from "../schemas/task.ts";
-import { detectProjectRoot, globalConfigPath, loadConfig, readDataRoots } from "../state/project.ts";
+import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
+import { detectProjectRoot, globalConfigPath, loadConfig, readDataRoots, readRawConfig } from "../state/project.ts";
+import { hasScoutThinking, SCOUT_THINKING } from "../schemas/configuration.ts";
 import {
   activeTask,
   claimTask,
   ownedTask,
   ownerlessTask,
-  createTaskDir,
-  ensureProjectStructure,
-  nextTaskId,
   saveTask,
   selectTask,
-  taskDirFor,
   taskHealth,
 } from "../state/persistence.ts";
 import { transition } from "../state/task-state.ts";
@@ -21,11 +17,16 @@ import { AGENT_DIR_NAMES, KNOWLEDGE_FILES, knowledgeDir, type KnowledgeAgent } f
 import { readFirstExisting } from "../knowledge/store.ts";
 import { overThreshold } from "../knowledge/compactor.ts";
 import { applyApprovalChoice, describeTask, describeOversizedKnowledge, type ApprovalChoice } from "../workflow/workflow.ts";
-import { shortTitle } from "../text.ts";
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
-import { applyMasterModel, openSettings } from "./settings-ui.ts";
+import { openSettings } from "./settings-ui.ts";
+import { kickoff, startTask } from "./start-task.ts";
+import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
+import { modelRef, thinkingMismatches } from "./model-support.ts";
+import { describeRun, runFromLog } from "./run-summary.ts";
+import { modelLookup } from "./tools.ts";
 
 const HELP = [
+  "/bot-lobby                  Open the lobby: tasks, plan, quick fix, issues, metrics (alt+l)",
   "/bot-lobby <request>        Start a task through the workflow",
   "/bot-lobby status [taskId]  Show the active task",
   "/bot-lobby tasks            List tasks",
@@ -33,14 +34,16 @@ const HELP = [
   "/bot-lobby cancel [taskId]  Abandon a task",
   "/bot-lobby approve|amend <text>|decline   Answer the current proposal",
   "/bot-lobby knowledge        Show persistent knowledge files",
+  "/bot-lobby runs [taskId]    Recent subagent runs: time, turns, tokens, cost, model",
   "/bot-lobby settings         Edit per-agent model/thinking/instructions",
   "/bot-lobby config           Show effective configuration",
   "/bot-lobby minimize|restore   Hide or restore bot-lobby for this session (ctrl+shift+m)",
   "/bot-lobby claim <taskId>    Take ownership of an orphaned task",
+  "/bot-lobby help             This help",
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["status", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "knowledge", "config", "settings", "minimize", "restore", "claim"]);
 
 function isTaskId(value: string | undefined): boolean {
   return Boolean(value && /^TASK-/.test(value));
@@ -56,52 +59,7 @@ function parseCommand(args: string): { sub: string | undefined; rest: string[];
   return { sub, rest, restText: trimmed.slice(sub.length).trim() };
 }
 
-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");
-}
-
-async function startTask(
-  pi: ExtensionAPI,
-  ctx: ExtensionCommandContext,
-  configDir: string,
-  request: string,
-): Promise<void> {
-  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;
-  }
-  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");
-  pi.sendUserMessage(kickoff(task));
-}
+export { kickoff };
 
 function showStatus(ctx: ExtensionCommandContext, configDir: string, taskId?: string): void {
   const root = detectProjectRoot(ctx.cwd, configDir);
@@ -118,6 +76,20 @@ function showStatus(ctx: ExtensionCommandContext, configDir: string, taskId?: st
   ctx.ui.notify(task ? `${describeTask(task)}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
 }
 
+/** Recent runs of the active (or named) task, newest last, so slow models are easy to spot. */
+export function runsReport(task: Task | undefined, limit = 20): string {
+  if (!task) return "No bot-lobby task found.";
+  const entries = (task.runLog ?? []).slice(-limit);
+  if (entries.length === 0) return `${task.id}: no finished subagent runs yet.`;
+  return [`${task.id} — last ${entries.length} run${entries.length === 1 ? "" : "s"}:`, ...entries.map((entry) => describeRun(runFromLog(entry, task.id)))].join("\n");
+}
+
+function showRuns(ctx: ExtensionCommandContext, configDir: string, taskId?: string): void {
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const task = selectTask(root, configDir, taskId, ctx.sessionManager.getSessionId()) ?? (taskId ? undefined : ownerlessTask(root, configDir));
+  ctx.ui.notify(runsReport(task), task ? "info" : "warning");
+}
+
 function showTasks(ctx: ExtensionCommandContext, configDir: string): void {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const { tasks, corrupted } = taskHealth(root, configDir);
@@ -208,7 +180,11 @@ function showKnowledge(ctx: ExtensionCommandContext, configDir: string): void {
 }
 
 function showConfig(ctx: ExtensionCommandContext): void {
-  ctx.ui.notify(`${globalConfigPath()}\n${JSON.stringify(loadConfig(), null, 2)}`, "info");
+  const config = loadConfig();
+  const warnings = thinkingMismatches(config, modelLookup(ctx), ctx.model ? modelRef(ctx.model) : undefined);
+  if (hasScoutThinking(readRawConfig())) warnings.push(`Scout: thinking is fixed at "${SCOUT_THINKING}"; the scout.thinking value in the file is ignored.`);
+  const notes = warnings.length > 0 ? `\n\nWarnings:\n${warnings.map((line) => `- ${line}`).join("\n")}` : "";
+  ctx.ui.notify(`${globalConfigPath()}\n${JSON.stringify(config, null, 2)}${notes}`, warnings.length > 0 ? "warning" : "info");
 }
 
 export function registerCommands(pi: ExtensionAPI, configDir: string): void {
@@ -223,14 +199,25 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
     handler: async (args, ctx) => {
       const { sub, rest, restText } = parseCommand(args ?? "");
       if (!sub) {
-        if (!restText) return ctx.ui.notify(HELP, "info");
-        return startTask(pi, ctx, configDir, restText);
+        if (!restText) {
+          if (!showLobby()) ctx.ui.notify(HELP, "info");
+          return;
+        }
+        if (await startTask(pi, ctx, configDir, restText)) autoOpenLobby();
+        return;
       }
       switch (sub) {
+        case "lobby":
+          if (!showLobby()) ctx.ui.notify("The lobby needs pi's interactive terminal UI.", "warning");
+          return;
+        case "help":
+          return ctx.ui.notify(HELP, "info");
         case "status":
           return showStatus(ctx, configDir, rest[0]);
         case "tasks":
           return showTasks(ctx, configDir);
+        case "runs":
+          return showRuns(ctx, configDir, rest[0]);
         case "pause":
           return setPaused(ctx, configDir, true, rest[0]);
         case "resume":

package/src/pi/events.ts

@@ -12,14 +12,17 @@ import { ORACLE_THINKING, oracleActivityWord } from "./activity.ts";
 import { isSubagentProcess, visibleTools } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
 import { taskRequest, type Task } from "../schemas/task.ts";
+import { pendingComments, readPlanComments, type PlanComment } from "../state/comments.ts";
 
-function masterTaskContext(task: Task): string {
+export function masterTaskContext(task: Task, comments: readonly PlanComment[] = []): string {
+  const open = pendingComments(comments);
   return [
     `Task ${task.id}: ${task.title}`,
     `Request: ${truncate(taskRequest(task), 2000)}`,
     task.proposal ? `Current proposal:\n${truncate(task.proposal, 2000)}` : "",
     task.plan ? `Approved plan:\n${truncate(task.plan, 3000)}` : "",
     task.amendments.length > 0 ? `User amendments:\n${task.amendments.map((entry) => `- ${entry}`).join("\n")}` : "",
+    open.length > 0 ? `Open plan comments (from the lobby):\n${open.map((comment) => `- ${truncate(comment.text, 600)}`).join("\n")}` : "",
   ]
     .filter((line) => line.length > 0)
     .join("\n\n");
@@ -86,7 +89,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
     const selected = selectKnowledge(`${taskRequest(task)} ${task.proposal ?? ""}`, slices);
     event.systemPromptOptions.sections["bot-lobby"] = compilePrompt({
       domain: "master",
-      task: masterTaskContext(task),
+      task: masterTaskContext(task, readPlanComments(root, configDir, task.id)),
       standards: selected.standards,
       knowledge: selected.knowledge,
       decisions: selected.decisions,

package/src/pi/expressions.ts

@@ -20,12 +20,19 @@ export const FAST_TICK_MS = 120;
 export const REST_FRAME = 0;
 export const BLINK_FRAME = 1;
 export const EMOTE_FRAME = 2;
-/** Emote frame range: `EMOTE_FRAME .. EMOTE_FRAME + EMOTE_FRAMES - 1`; an emote steps through them. */
-export const EMOTE_FRAMES = 2;
+/**
+ * Emote frame range: `EMOTE_FRAME .. EMOTE_FRAME + EMOTE_FRAMES - 1`; an emote
+ * steps through them: the open face, a blink, then its action (see kaomoji.ts).
+ */
+export const EMOTE_FRAMES = 4;
 /** Each emote frame is held this long, so an emote steps through its frames. */
 export const EMOTE_STEP_MS = Math.floor(EMOTE_MS / EMOTE_FRAMES);
 
 const BLINK_CHANCE = 0.65;
+/** Working agents emote as often as they blink. */
+export const WORKING_BLINK_CHANCE = 0.5;
+/** Upper bound (exclusive) of an expression's variant. */
+const VARIANT_SPAN = 2 ** 30;
 
 export interface ExpressionState {
   /** Earliest `now` the next expression may start. */
@@ -36,6 +43,8 @@ export interface ExpressionState {
   startedAt: number;
   /** Frame index for the art: 0 rest, 1 blink, 2+ emote. */
   frame: number;
+  /** Drawn once per expression; picks which face an emote shows (see kaomoji.ts). */
+  variant: number;
 }
 
 /** A random draw clamped to `[0, 1]`, so a non-finite source value can never leak. */
@@ -50,8 +59,10 @@ export interface ExpressionGap {
   max: number;
 }
 
-/** Agent slots rest 20-30 s between expressions. */
+/** Idle agent slots rest 20-30 s between expressions. */
 export const SLOT_GAP: ExpressionGap = { min: BLINK_MIN_MS, max: BLINK_MAX_MS };
+/** Working agents are livelier: 8-15 s between expressions. */
+export const WORKING_GAP: ExpressionGap = { min: 8_000, max: 15_000 };
 /** The oracle is the scene's centrepiece: it blinks and emotes every 6-12 s. */
 export const ORACLE_GAP: ExpressionGap = { min: 6_000, max: 12_000 };
 
@@ -60,15 +71,19 @@ export function nextGap(rng: () => number, gap: ExpressionGap = SLOT_GAP): numbe
   return gap.min + Math.round(unit(rng) * (gap.max - gap.min));
 }
 
-/** Whether the next expression blinks (~65%) or emotes (~35%). */
-export function pickEvent(rng: () => number): "blink" | "emote" {
-  return unit(rng) < BLINK_CHANCE ? "blink" : "emote";
+/** Whether the next expression blinks (~65% by default) or emotes. */
+export function pickEvent(rng: () => number, blinkChance = BLINK_CHANCE): "blink" | "emote" {
+  return unit(rng) < blinkChance ? "blink" : "emote";
+}
+
+function drawVariant(rng: () => number): number {
+  return Math.floor(unit(rng) * (VARIANT_SPAN - 1));
 }
 
 /** A freshly rested expression that fires for the first time after one random gap. */
 export function createExpression(now: number, rng: () => number, gap: ExpressionGap = SLOT_GAP): ExpressionState {
   const start = Number.isFinite(now) ? now : 0;
-  return { nextAt: start + nextGap(rng, gap), until: start, startedAt: start, frame: REST_FRAME };
+  return { nextAt: start + nextGap(rng, gap), until: start, startedAt: start, frame: REST_FRAME, variant: 0 };
 }
 
 /** True while `now` is inside a playing blink or emote. */
@@ -90,17 +105,33 @@ export function advanceExpression(
   now: number,
   rng: () => number,
   gap: ExpressionGap = SLOT_GAP,
+  blinkChance = BLINK_CHANCE,
 ): ExpressionState {
   if (!Number.isFinite(now)) return state;
   if (now < state.until) return state.frame >= EMOTE_FRAME ? steppedEmote(state, now) : state;
   if (now < state.nextAt) return state.frame === REST_FRAME ? state : { ...state, frame: REST_FRAME };
-  return play(now, rng, gap);
+  return play(now, rng, gap, blinkChance);
+}
+
+function play(now: number, rng: () => number, gap: ExpressionGap, blinkChance: number): ExpressionState {
+  const blink = pickEvent(rng, blinkChance) === "blink";
+  return blink ? startBlink(now, rng, gap) : triggerEmote(now, rng, gap);
 }
 
-function play(now: number, rng: () => number, gap: ExpressionGap): ExpressionState {
-  const blink = pickEvent(rng) === "blink";
-  const until = now + (blink ? BLINK_MS : EMOTE_MS);
-  return { nextAt: until + nextGap(rng, gap), until, startedAt: now, frame: blink ? BLINK_FRAME : EMOTE_FRAME };
+function startBlink(now: number, rng: () => number, gap: ExpressionGap): ExpressionState {
+  const until = now + BLINK_MS;
+  return { nextAt: until + nextGap(rng, gap), until, startedAt: now, frame: BLINK_FRAME, variant: drawVariant(rng) };
+}
+
+/**
+ * Start an emote right now, whatever the sprite was doing: the reaction when a
+ * slot's situation changes (it starts, finishes, fails, stalls, waits or
+ * receives a file). The next scheduled expression follows one gap later.
+ */
+export function triggerEmote(now: number, rng: () => number, gap: ExpressionGap = SLOT_GAP): ExpressionState {
+  const start = Number.isFinite(now) ? now : 0;
+  const until = start + EMOTE_MS;
+  return { nextAt: until + nextGap(rng, gap), until, startedAt: start, frame: EMOTE_FRAME, variant: drawVariant(rng) };
 }
 
 /** One sub-step of a playing expression; the oracle's blink and glance step through these. */