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

package/src/pi/activity.ts

@@ -106,3 +106,123 @@ export function activityDetail(toolName: string, args?: unknown): string | undef
   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,7 +1,6 @@
-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 { 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 {
@@ -9,12 +8,8 @@ import {
   claimTask,
   ownedTask,
   ownerlessTask,
-  createTaskDir,
-  ensureProjectStructure,
-  nextTaskId,
   saveTask,
   selectTask,
-  taskDirFor,
   taskHealth,
 } from "../state/persistence.ts";
 import { transition } from "../state/task-state.ts";
@@ -22,14 +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",
@@ -42,10 +39,11 @@ const HELP = [
   "/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", "runs", "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));
@@ -61,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);
@@ -246,10 +199,19 @@ 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":

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/model-support.ts

@@ -2,6 +2,10 @@ import { clampThinkingLevel, getSupportedThinkingLevels, type Api, type Model, t
 import {
   agentProfile,
   isThinkingLevel,
+  lobbyAgentProfile,
+  panelMemberProfile,
+  type LobbyAgentKind,
+  type PanelMember,
   THINKING_LEVELS,
   type BotLobbyConfig,
   type ProfileResolver,
@@ -47,6 +51,8 @@ const LABELS: Record<SubagentKind | "master", string> = {
   qa: "QA",
   scout: "Scout",
   researcher: "Researcher",
+  quickfix: "Quick fix",
+  planner: "Planner",
 };
 
 export function kindLabel(kind: SubagentKind | "master"): string {
@@ -84,6 +90,32 @@ export function createProfileResolver(config: BotLobbyConfig, options: ResolverO
   };
 }
 
+type RunProfile = { model?: string; thinking: string; timeoutMs: number; instructions?: string };
+
+/** Unset models run on the session's; thinking is clamped to the model, with a one-time warning. */
+function resolveRunProfile(profile: RunProfile, label: string, options: ResolverOptions): RunProfile {
+  const model = profile.model ?? options.sessionModel;
+  const check = checkThinking(model ? options.lookup(model) : undefined, profile.thinking);
+  if (check.warning) {
+    const message = `bot-lobby: ${label} — ${check.warning}. Change it in /bot-lobby settings.`;
+    if (!warned.has(message)) {
+      warned.add(message);
+      options.warn?.(message);
+    }
+  }
+  return { ...profile, model, thinking: check.level };
+}
+
+/** A lobby agent's model, thinking and time limit. */
+export function resolveLobbyProfile(config: BotLobbyConfig, kind: LobbyAgentKind, options: ResolverOptions): RunProfile {
+  return resolveRunProfile(lobbyAgentProfile(config, kind), kindLabel(kind), options);
+}
+
+/** A planning panel seat's model, thinking and time limit, from its domain's (or the researcher's) settings. */
+export function resolvePanelProfile(config: BotLobbyConfig, member: PanelMember, options: ResolverOptions): RunProfile {
+  return resolveRunProfile(panelMemberProfile(config, member), kindLabel(member), options);
+}
+
 /** Every configured subagent whose thinking level its model does not support, for `/bot-lobby config`. */
 export function thinkingMismatches(config: BotLobbyConfig, lookup: ModelLookup, sessionModel?: string): string[] {
   const entries: Array<[SubagentKind | "master", string, string]> = [
@@ -92,6 +124,8 @@ export function thinkingMismatches(config: BotLobbyConfig, lookup: ModelLookup,
     ["backend", config.agents.backend.model, config.agents.backend.thinking],
     ["qa", config.agents.qa.model, config.agents.qa.thinking],
     ["researcher", config.researcher.model, config.researcher.thinking],
+    ["quickfix", config.quickFix.model, config.quickFix.thinking],
+    ["planner", config.planner.model, config.planner.thinking],
   ];
   return entries.flatMap(([kind, ref, level]) => {
     const model = ref === "inherit" ? sessionModel : ref;

package/src/pi/run-summary.ts

@@ -80,6 +80,7 @@ export function runLogEntry(run: AgentRun): RunLogEntry {
     startedAt: run.startedAt,
     ...(run.finishedAt ? { finishedAt: run.finishedAt } : {}),
     ...(run.model ? { model: run.model } : {}),
+    ...(run.thinking ? { thinking: run.thinking } : {}),
     ...(run.turns ?? run.usage?.turns ? { turns: run.turns ?? run.usage?.turns } : {}),
     ...(run.tools ? { tools: run.tools } : {}),
     ...(run.usage ? { input: run.usage.input, output: run.usage.output, cost: run.usage.cost } : {}),
@@ -103,6 +104,7 @@ export function runFromLog(entry: RunLogEntry, taskId: string): AgentRun {
     startedAt: entry.startedAt,
     ...(entry.finishedAt ? { finishedAt: entry.finishedAt } : {}),
     ...(entry.model ? { model: entry.model } : {}),
+    ...(entry.thinking ? { thinking: entry.thinking } : {}),
     ...(entry.turns ? { turns: entry.turns } : {}),
     ...(entry.tools ? { tools: entry.tools } : {}),
     ...(entry.input !== undefined ? { usage: { input: entry.input, output: entry.output ?? 0, cost: entry.cost ?? 0, turns: entry.turns ?? 0 } } : {}),

package/src/pi/settings-ui.ts

@@ -38,6 +38,8 @@ 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];
 }
 
@@ -58,6 +60,8 @@ export function patchEntry(config: BotLobbyConfig, kind: SettingsKind, patch: En
       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;
 }

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

@@ -27,7 +27,7 @@ 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(
@@ -59,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 a step to a domain worker, or several domains in parallel with assignments), 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",