@a-t-h-i/bot-lobby 0.6.4 → 0.6.6

package/src/pi/route.ts

@@ -0,0 +1,180 @@
+/**
+ * Where a new request goes before any task exists. The classifier (Jev, or
+ * the rules while it is off) reads whether one agent can do it alone, right
+ * away. When it can, the oracle confirms with `route_request`: the lobby hands
+ * the request to the quick-fix agent and shows the Quick fix tab. Otherwise,
+ * or when the oracle says it needs the team, the task starts as before.
+ *
+ * Nothing is routed without the lobby (it runs quick fixes), when routing is
+ * off (`workflow.routeQuickFixes`), or for a request the user already placed
+ * (`--task`, `--fast`, `--full`) or a planned task.
+ */
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import type { Domain } from "../schemas/agent.ts";
+import type { TaskTriage } from "../schemas/task.ts";
+import { chooseRoute, type RequestRoute } from "../workflow/track.ts";
+import { triageFor } from "../classifier/instance.ts";
+import { ownedTask } from "../state/persistence.ts";
+import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { lobbyFeed } from "../lobby/feed.ts";
+import { startTask, type StartOptions } from "./start-task.ts";
+import { isQuiet, isSubagentProcess } from "./quiet.ts";
+
+export const ROUTE_TOOL = "route_request";
+
+/**
+ * Hands a request to the lobby's quick-fix agent and shows the Quick fix tab;
+ * the job's id, or undefined without a lobby. `builder` is set for a quick
+ * feature: it runs on that domain's model, thinking and time limit.
+ */
+export type QuickFixHandoff = (request: string, builder: Domain | undefined, reason: string) => string | undefined;
+
+let handoff: QuickFixHandoff | undefined;
+
+/** The lobby registers its quick-fix hand-off while it runs. */
+export function setQuickFixHandoff(next: QuickFixHandoff | undefined): void {
+  handoff = next;
+}
+
+interface Pending {
+  request: string;
+  options: StartOptions;
+  route: RequestRoute;
+  at: number;
+}
+
+let pending: Pending | undefined;
+
+/** A request the oracle has not routed in this long is forgotten: the next one starts afresh. */
+const STALE_MS = 30 * 60_000;
+
+/** The request waiting for the oracle to route it, if any. */
+export function pendingRequest(now = Date.now()): { request: string; route: RequestRoute } | undefined {
+  if (pending && now - pending.at >= STALE_MS) pending = undefined;
+  return pending ? { request: pending.request, route: pending.route } : undefined;
+}
+
+/** A quick feature (bigger than a small change, but self-contained) runs with its builder's settings; a quick fix with the quick-fix agent's. */
+function builderFor(route: RequestRoute): Domain | undefined {
+  return route.size === "medium" || route.size === "large" ? route.builder : undefined;
+}
+
+/** What the oracle is asked: one step, from the request alone. */
+export function routeMessage(request: string, route: RequestRoute): string {
+  return [
+    "bot-lobby: a new request, not a task yet.",
+    `Request: ${request}`,
+    `Read: a ${builderFor(route) ? "quick feature" : "quick fix"} — ${route.reasons.join("; ")} (${route.source}).`,
+    "",
+    "Confirm where it goes with route_request, in one step and from the request alone: do not read files, plan or ask.",
+    "- to=quickfix: one agent does it now and the lobby shows it on the Quick fix tab. Right for anything one person can just do, even a rich piece of work in one file.",
+    "- to=task: the team (bot-lobby's workflow), when it needs several areas agreeing on a contract, a survey of an unfamiliar codebase, a risky change, or decisions the user must make first.",
+    "Then tell the user in one line where it went.",
+  ].join("\n");
+}
+
+export interface RequestOptions extends StartOptions {
+  /** `--task`: always a task. */
+  task?: boolean;
+}
+
+/**
+ * A new request from the lobby or `/bot-lobby <request>`: a task at once, or
+ * (when it reads as one agent's work) a question to the oracle first.
+ * Resolves with what happened.
+ */
+export async function startRequest(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, request: string, options: RequestOptions = {}): Promise<"task" | "routing" | undefined> {
+  const { task: asTask, ...start } = options;
+  const config = loadConfig();
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const placed = asTask || start.track || start.approvedPlan || !config.workflow.routeQuickFixes || !handoff;
+  // A session that already drives a task gets startTask's own warning.
+  if (placed || ownedTask(root, configDir, ctx.sessionManager.getSessionId())) {
+    return (await startTask(pi, ctx, configDir, request, start)) ? "task" : undefined;
+  }
+  const triage = await triageFor({ cwd: ctx.cwd, root, configDir }, request);
+  const route = chooseRoute(request, triage, config.classifier.thresholds.quickFixAt);
+  const read: StartOptions = { ...start, triaged: true, ...(triage ? { triage } : {}) };
+  if (route.to === "task") return (await startTask(pi, ctx, configDir, request, read)) ? "task" : undefined;
+  pending = { request, options: read, route, at: Date.now() };
+  lobbyFeed.log("LOBBY", `reads as a ${builderFor(route) ? "quick feature" : "quick fix"} (${route.source}): ${route.reasons[0]} — the oracle confirms`, "info");
+  pi.sendUserMessage(routeMessage(request, route), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  return "routing";
+}
+
+const RouteSchema = Type.Object({
+  to: StringEnum(["quickfix", "task"] as const, { description: "quickfix: one agent does it now, on the lobby's Quick fix tab; task: the team (bot-lobby's workflow)" }),
+  reason: Type.Optional(Type.String({ description: "one line: why it goes there" })),
+  request: Type.Optional(Type.String({ description: "the request as it should be done, when the user refined it since; their words otherwise" })),
+});
+
+/** The oracle's answer to a routing question: the quick-fix agent, or a task. */
+export async function routeRequest(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, params: { to: "quickfix" | "task"; reason?: string; request?: string }): Promise<{ ok: boolean; text: string }> {
+  const waiting = pendingRequest();
+  if (!waiting || !pending) return { ok: false, text: "No request is waiting to be routed. Start a task with /bot-lobby <request>." };
+  const { options, route } = pending;
+  const request = params.request?.trim() || pending.request;
+  pending = undefined;
+  const why = params.reason?.trim();
+  if (params.to === "quickfix") {
+    const id = handoff?.(request, builderFor(route), why || route.reasons[0] || "one agent can do it alone");
+    if (id) {
+      lobbyFeed.log("LOBBY", `the oracle sent it to the quick-fix agent: ${id}${why ? ` — ${why}` : ""}`, "success");
+      return { ok: true, text: `${id} is running on the lobby's Quick fix tab, which is now open. Tell the user in one line that this looks like a ${builderFor(route) ? "quick feature" : "quick fix"} and the quick-fix agent is on it; nothing else to do.` };
+    }
+    // No lobby to run it any more: it becomes a task.
+  }
+  lobbyFeed.log("LOBBY", `the oracle sent it to the team${why ? ` — ${why}` : ""}`, "info");
+  const task = await startTask(pi, ctx, configDir, request, { ...options, routed: true });
+  return task
+    ? { ok: true, text: `Started ${task.id} as a task; its kickoff follows as the next message. Say nothing more now.` }
+    : { ok: false, text: "Could not start a task: this session already drives one (finish or cancel it first)." };
+}
+
+/**
+ * `route_request`, active only while a request waits for the oracle, so it
+ * never sits in the tool list of plain pi or of a running task.
+ */
+export function registerRouteTool(pi: ExtensionAPI, configDir: string): void {
+  if (isSubagentProcess()) return;
+  pi.on("session_start", () => {
+    pending = undefined;
+  });
+  pi.on("before_agent_start", () => {
+    const active = pi.getActiveTools();
+    const want = Boolean(pendingRequest());
+    if (want === active.includes(ROUTE_TOOL)) return;
+    pi.setActiveTools(want ? [...active, ROUTE_TOOL] : active.filter((name) => name !== ROUTE_TOOL));
+  });
+  pi.registerTool({
+    name: ROUTE_TOOL,
+    label: "Route request",
+    description: "Send a new bot-lobby request to the quick-fix agent (to=quickfix: one agent does it now, shown on the lobby's Quick fix tab) or to the team (to=task: bot-lobby's workflow). Only while a request waits to be routed.",
+    promptSnippet: "Route a new bot-lobby request: quickfix (one agent now) or task (the team)",
+    parameters: RouteSchema,
+    renderShell: "self",
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const result = await routeRequest(pi, ctx, configDir, params as { to: "quickfix" | "task"; reason?: string; request?: string });
+      return { content: [{ type: "text", text: result.text }], details: { ok: result.ok, to: (params as { to: string }).to } };
+    },
+    renderCall(args, theme) {
+      if (isQuiet()) return new Container();
+      const call = args as { to?: string };
+      return new Text(`${theme.fg("toolTitle", theme.bold("route_request"))} ${theme.fg("accent", call.to ?? "")}`, 0, 0);
+    },
+    renderResult(result, _options, theme) {
+      if (isQuiet()) return new Container();
+      const details = result.details as { ok?: boolean; to?: string } | undefined;
+      const icon = details?.ok ? theme.fg("success", "✓") : theme.fg("warning", "!");
+      return new Text(`${icon} ${theme.fg("toolTitle", theme.bold("route_request"))} ${theme.fg("muted", `→ ${details?.to === "quickfix" ? "Quick fix tab" : "a task"}`)}`, 0, 0);
+    },
+  });
+}
+
+/** Tests: forget any request waiting for the oracle. */
+export function clearPendingRequest(): void {
+  pending = undefined;
+}

package/src/pi/run-summary.ts

@@ -6,16 +6,25 @@
 import type { AgentRun } from "../schemas/findings.ts";
 import type { RunLogEntry } from "../schemas/task.ts";
 import { shortDuration } from "../text.ts";
-import { SLOT_LABELS, type SlotId } from "./mascot-art.ts";
 
-/** The zen column a run belongs to; a researcher reports under RESEARCH from any domain. */
+export type SlotId = "dev" | "design" | "research" | "qa";
+
+/** Uppercase agent names. */
+const SLOT_LABELS: Record<SlotId, string> = {
+  dev: "DEV",
+  design: "DESIGN",
+  research: "RESEARCH",
+  qa: "QA",
+};
+
+/** The agent slot a run belongs to; a researcher reports under RESEARCH from any domain. */
 export function slotOf(run: Pick<AgentRun, "domain" | "role">): SlotId {
   if (run.role === "researcher") return "research";
   if (run.domain === "backend") return "dev";
   return run.domain === "designer" ? "design" : "qa";
 }
 
-/** Upper-case agent name as the scene shows it (DEV, DESIGN, RESEARCH, QA). */
+/** Upper-case agent name (DEV, DESIGN, RESEARCH, QA). */
 export function agentName(run: Pick<AgentRun, "domain" | "role">): string {
   return SLOT_LABELS[slotOf(run)];
 }

package/src/pi/settings-ui.ts

@@ -358,7 +358,7 @@ function entryDescription(kind: SettingsKind, view: EntryView): string {
 /** The lobby's on/off settings as the settings menu lists them; `panel:*` are the Lobby tab's panes. */
 export type LobbySwitch = "autoOpen" | "autoAsk" | "mouse" | "issues" | `panel:${LobbyPanel}`;
 
-const PANEL_SWITCH_LABELS: Record<LobbyPanel, string> = { animations: "Animations in the lobby", conversation: "Conversation pane", activity: "Activity log pane", thinking: "Thinking pane" };
+const PANEL_SWITCH_LABELS: Record<LobbyPanel, string> = { conversation: "Conversation pane", activity: "Activity log pane", thinking: "Thinking pane" };
 
 export const LOBBY_SWITCHES: ReadonlyArray<{ id: LobbySwitch; label: string; help: string }> = [
   { id: "autoOpen", label: "Open with a task", help: "open the lobby when this session starts or resumes a task" },
@@ -368,7 +368,7 @@ export const LOBBY_SWITCHES: ReadonlyArray<{ id: LobbySwitch; label: string; hel
   ...LOBBY_PANELS.map((panel) => ({
     id: `panel:${panel}` as const,
     label: PANEL_SWITCH_LABELS[panel],
-    help: panel === "animations" ? "the animated oracle and agents on the Lobby tab; off keeps only the task's status (they still show above pi's editor while the lobby is hidden); alt+z toggles it too" : "shown on the Lobby tab; its key in the lobby toggles it too",
+    help: "shown on the Lobby tab; its key in the lobby toggles it too",
   })),
 ];
 

package/src/pi/start-task.ts

@@ -5,7 +5,10 @@
  */
 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 { createTask, taskRequest, type Task, type TaskTrack, type TaskTriage, type TrackPath } from "../schemas/task.ts";
+import type { Domain } from "../schemas/agent.ts";
+import { chooseTrack, trackLine, trackSummary } from "../workflow/track.ts";
+import { lobbyFeed } from "../lobby/feed.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";
@@ -26,19 +29,51 @@ function uniqueTaskId(root: string, configDir: string, request: string): string
   return id;
 }
 
-export function kickoff(task: Task, budgetMinutes = 0): string {
+/** In a kickoff after the oracle routed the request to the team (the lobby then shows the request once). */
+export const ROUTED_LINE = "Routed: you sent this request to the team.";
+
+/** The fast track's steps: straight to the agents the request needs, QA only for tests, then complete. */
+function fastSteps(track: TaskTrack): string[] {
+  const building = track.roster.filter((member): member is Domain => member === "designer" || member === "backend");
+  const builders = building.length > 1
+    ? `one call with assignments for ${building.join(" and ")}, each task stating the contract between them`
+    : building.length === 1 ? `domain ${building[0]}` : track.roster.includes("qa") ? "domain qa (the change is its tests)" : "the one domain that owns the files";
+  const steps = [
+    ...(track.roster.includes("researcher") ? ["First summon the researcher for the outside facts it needs: orchestrate action=research with a domain and the question."] : []),
+    `Delegate now with orchestrate action=implement: ${builders}; open each task with "Step 1:" (the engine keeps the plan).`,
+    ...(track.roster.includes("qa") && building.length > 0 ? ["QA takes part (tests): once the change is in, give qa the tests as the last step (action=implement domain=qa), or run action=qa."] : []),
+    "Check `git diff --stat` and the report, then orchestrate action=complete with a one-line summary.",
+  ];
   return [
+    "Fast track: the request reads small and clear, so skip the ceremony: no scouts, no proposal, no plan document.",
+    ...steps.map((step, index) => `${index + 1}. ${step}`),
+    track.roster.includes("qa") ? "" : "No QA gate on this track: nothing here needs tests.",
+    "If the request is bigger, riskier or less clear than it reads, switch before delegating: orchestrate action=track track=full with a reason. Otherwise do not deliberate over the track.",
+  ].filter(Boolean);
+}
+
+export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: boolean; routed?: boolean } = {}): string {
+  const track = task.track;
+  const head = [
     `A bot-lobby task is active: ${task.id}`,
     `Title: ${task.title}`,
     `Request: ${taskRequest(task)}`,
     `State: ${task.state}`,
+    ...(options.routed ? [ROUTED_LINE] : []),
+    ...(track ? [trackSummary(track)] : []),
     ...(budgetMinutes > 0 ? [`Time budget: ${budgetMinutes} minutes of work, for you and every agent. Size the plan to fit it and divide it by scope (see Time budget in your prompt).`] : []),
     "",
+  ];
+  if (track?.path === "fast") return [...head, ...fastSteps(track)].join("\n");
+  const fastAllowed = Boolean(track) && options.fastTrack !== false && track?.userChoice !== "full" && track?.source !== "plan";
+  return [
+    ...head,
     "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.",
+    ...(fastAllowed ? ["If it is in fact a small, clear, low-risk change, take the fast track instead: orchestrate action=track track=fast with a reason."] : []),
   ].join("\n");
 }
 
@@ -56,6 +91,13 @@ export interface StartOptions {
   title?: string;
   /** Minutes of work time the task gets; `workflow.taskBudgetMinutes` when absent. */
   budget?: number;
+  /** The user's `--fast` or `--full`: the path the task takes, whatever its request reads as. */
+  track?: TrackPath;
+  /** The classifier already read the request (routing did): `triage` is its read, or absent when it was off. */
+  triaged?: boolean;
+  triage?: TaskTriage;
+  /** The oracle sent this request to the team after the classifier read it as a quick fix. */
+  routed?: boolean;
 }
 
 export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, request: string, options: StartOptions = {}): Promise<Task | undefined> {
@@ -72,10 +114,14 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   createTaskDir(root, configDir, task);
   transition(task, "clarifying");
   // The classifier's read of the request (when it is on) reaches the Master's very first turn.
-  const triage = await triageFor({ cwd: ctx.cwd, root, configDir }, request);
+  const triage = options.triaged ? options.triage : await triageFor({ cwd: ctx.cwd, root, configDir }, request);
   if (triage) task.triage = triage;
+  // How serious the request reads: who takes part, and whether it takes the fast track or the full workflow.
+  const config = loadConfig();
+  task.track = chooseTrack(request, triage, { fastTrack: config.workflow.fastTrack, ...(options.track ? { forced: options.track } : {}), ...(options.approvedPlan ? { approvedPlan: true } : {}) });
+  lobbyFeed.log("LOBBY", trackLine(task.track), "info");
   saveTask(root, configDir, task);
-  const budgetMinutes = options.budget ?? loadConfig().workflow.taskBudgetMinutes;
+  const budgetMinutes = options.budget ?? config.workflow.taskBudgetMinutes;
   if (budgetMinutes > 0) setBudget(root, configDir, task.id, budgetMinutes);
   if (options.auto) setAutoMode(root, configDir, task.id, true, sessionId);
   // A session that starts a task is named after it, so /resume and the lobby list it by name.
@@ -86,7 +132,7 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   // The oracle takes the task on with a clean context: nothing said before the kickoff is sent to its model.
   if (freshContextOn()) markContext(pi, { kind: "start", taskId: task.id, at: Date.now() });
   // A kickoff while pi is still busy (another turn) queues behind it instead of throwing.
-  pi.sendUserMessage(kickoff(task, budgetMinutes), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  pi.sendUserMessage(kickoff(task, budgetMinutes, { fastTrack: config.workflow.fastTrack, ...(options.routed ? { routed: true } : {}) }), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
   return task;
 }
 

package/src/pi/tools.ts

@@ -29,17 +29,17 @@ const OrchestrateSchema = Type.Object({
   question: Type.Optional(Type.String({ description: "clarify: question for the user" })),
   options: Type.Optional(Type.Array(Type.String(), { description: "clarify: optional answer choices; put your recommended one first and mark it (Recommended)" })),
   domains: Type.Optional(Type.Array(Type.String(), { description: "scout: any of designer, backend, qa" })),
-  instruction: Type.Optional(Type.String({ description: "scout/research: what to investigate (for scout, also used to target-verify a claim)" })),
+  instruction: Type.Optional(Type.String({ description: "scout/research: a self-contained brief: the specific questions, where to look, the answer format you want (paths, names, versions, evidence) and what you will do with it. The agent may be a small model: assume nothing" })),
   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 (while implementing or reviewing, the full revised plan that replaces it)" })),
+  plan: Type.Optional(Type.String({ description: "plan: the detailed internal plan (while implementing or reviewing, the full revised plan that replaces it). Every step names its files, its concrete actions and its done criteria, and the contracts between domains are written out; no decision is left to the workers" })),
   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" })),
+  task: Type.Optional(Type.String({ description: "implement: a self-contained brief for that domain's worker (which may be a small, literal model): Goal, exact Files, numbered What to do with names/shapes/values, Contracts, Constraints, Done when (checkable criteria and commands), If stuck. Decide everything yourself; leave nothing to be assumed" })),
   assignments: Type.Optional(
     Type.Array(
       Type.Object({
         domain: Type.String({ description: "designer, backend, or qa" }),
-        task: Type.String({ description: "the concrete step(s) for that domain's worker" }),
+        task: Type.String({ description: "a self-contained brief for that domain's worker: Goal, exact Files, numbered What to do, Contracts (in full), Constraints, Done when, If stuck. No assumptions" }),
         minutes: Type.Optional(Type.Number({ description: "under a time budget: minutes for this worker, by its scope" })),
       }),
       { description: "implement: run several domains in parallel (distinct domains); workers share files through the file desk" },
@@ -51,7 +51,11 @@ const OrchestrateSchema = Type.Object({
     StringEnum(["approved", "rejected"] as const, { description: "resolve_approval: approve or reject the request" }),
   ),
   note: Type.Optional(Type.String({ description: "resolve_approval: rationale, or what to do instead when rejected" })),
-  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue; budget: why the task needs more time" })),
+  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue; budget: why the task needs more time; track: why the task takes that path or needs those members" })),
+  track: Type.Optional(
+    StringEnum(["fast", "full"] as const, { description: "track: fast (straight to the roster's agents, no scouts, proposal or plan; QA only for tests) or full (the whole workflow)" }),
+  ),
+  roster: Type.Optional(Type.Array(Type.String(), { description: "track: who takes part — any of designer, backend, qa, researcher" })),
   text: Type.Optional(Type.String({ description: "decide/complete/knowledge: the decision, completion summary, or knowledge text" })),
   file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md" })),
   kind: Type.Optional(
@@ -71,7 +75,9 @@ const DESCRIPTION = [
   "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",
   "pass), block/resume (escalate or continue), budget (under a time budget: where it stands, or ask the",
-  "user for more minutes with a reason), status, cancel.",
+  "user for more minutes with a reason), track (the task's path and who takes part: show it, or correct it with",
+  "track=fast|full, roster and a reason), status, cancel.",
+  "Every instruction you give an agent is read by a possibly smaller, cheaper model that cannot infer intent: write each one as a complete, explicit brief with the goal, files, actions, contracts, constraints and done criteria, then check the report against it.",
   "The engine validates every step against the task state machine, so a rejected action means the workflow is not at that step yet.",
 ].join(" ");
 
@@ -184,7 +190,7 @@ export function registerOrchestrateTool(pi: ExtensionAPI, configDir: string, run
     name: "orchestrate",
     label: "Orchestrate",
     description: DESCRIPTION,
-    promptSnippet: "Run a bot-lobby workflow step (clarify, scout, propose, plan, decide, status, cancel)",
+    promptSnippet: "Run a bot-lobby workflow step (clarify, scout, propose, plan, implement, track, decide, status, cancel)",
     promptGuidelines: [
       "Use orchestrate for every bot-lobby workflow step; it enforces the task state machine and records results.",
     ],