@a-t-h-i/bot-lobby 0.6.7 → 0.6.8

package/src/master/master.ts

@@ -6,7 +6,7 @@ import type { AgentRun, ReviewResult, ScoutResult, WorkerResult } from "../schem
 import { domainSpec } from "../agents/registry.ts";
 import { runAgent, runParallel, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner, type RelayAsk } from "../execution/pi-runner.ts";
-import { readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
+import { knowledgeFilePath, readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
 import { selectKnowledge, type KnowledgeSelection } from "../knowledge/selector.ts";
 import { summarizeOutcomes } from "./synthesis.ts";
 import { parseWorkerResult, validateWorkerResult } from "../roles/worker.ts";
@@ -14,6 +14,7 @@ import { parseReviewResult, validateReviewResult } from "../roles/reviewer.ts";
 import { truncate } from "../text.ts";
 import { isScoutResultUsable, parseScoutResult, validateScoutResult } from "../roles/scout.ts";
 import type { FileHinter } from "../classifier/files.ts";
+import type { KnowledgePaths, KnowledgePicker } from "../classifier/knowledge.ts";
 import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRouter } from "../classifier/effort.ts";
 
 export interface ScoutOutcome {
@@ -42,6 +43,8 @@ export interface ScoutRequest {
   onUpdate?: (run: AgentRun) => void;
   /** Likely files for each scout's context, and the lookup tool, while the classifier's file hints are on. */
   hints?: FileHinter;
+  /** Picks the relevant sections of long knowledge files, while the classifier's knowledge picks are on. */
+  knowledge?: KnowledgePicker;
   /** Moves a trivial scout to the cheaper model, while the classifier's effort routing is on. */
   effort?: EffortRouter;
 }
@@ -61,11 +64,31 @@ function scoutInstruction(request: ScoutRequest, domain: Domain): string {
   ].join("\n");
 }
 
-function scoutContext(request: ScoutRequest, domain: Domain, likely = ""): AgentRequest["context"] {
-  const slices = readAgentKnowledge(request.dataRoots, domain);
+/** Where an agent's knowledge files are, for the note that says what a prompt left out. */
+function knowledgePaths(dataRoots: readonly string[], agent: Domain): KnowledgePaths {
+  const root = dataRoots[0];
+  return root ? { knowledge: knowledgeFilePath(root, agent, "knowledge"), standards: knowledgeFilePath(root, agent, "standard"), decisions: knowledgeFilePath(root, agent, "decision") } : {};
+}
+
+/**
+ * What an agent's prompt carries of its knowledge for a step: Jev's picks from
+ * the files that are too long when a picker is given, the keyword selection
+ * otherwise and whenever the picker fails.
+ */
+async function pickKnowledge(request: { knowledge?: KnowledgePicker; dataRoots: readonly string[]; signal?: AbortSignal }, agent: Domain, query: string): Promise<KnowledgeSelection> {
+  const slices = readAgentKnowledge(request.dataRoots, agent);
+  if (!request.knowledge) return selectKnowledge(query, slices);
+  try {
+    return await request.knowledge.select(query, slices, { paths: knowledgePaths(request.dataRoots, agent), ...(request.signal ? { signal: request.signal } : {}) });
+  } catch {
+    return selectKnowledge(query, slices);
+  }
+}
+
+function scoutContext(request: ScoutRequest, domain: Domain, selected: KnowledgeSelection, likely = ""): AgentRequest["context"] {
   return {
     task: request.taskText,
-    ...selectKnowledge(`${request.taskText} ${domainSpec(domain).scoutFocus}`, slices),
+    ...selected,
     instructions: request.config.agents[domain].instructions,
     workflowContext: [`Task state: scouting. Domain: ${domain}. Read-only reconnaissance; no implementation.`, likely, request.time?.note ?? ""].filter(Boolean).join("\n\n"),
   };
@@ -112,14 +135,17 @@ function toOutcome(run: AgentRun, domain: Domain): ScoutOutcome {
 /** Run the selected domain scouts concurrently and persist their findings. */
 export async function runScouts(request: ScoutRequest, run: ProcessRunner = spawnPiProcess): Promise<ScoutOutcome[]> {
   // Each scout gets the files most likely to answer its own instruction and focus.
-  const likely = await Promise.all(request.domains.map((domain) => likelyFor(request.hints, `${request.instruction}\n${domainSpec(domain).scoutFocus}`, request.signal, request.taskText)));
+  const [likely, selected] = await Promise.all([
+    Promise.all(request.domains.map((domain) => likelyFor(request.hints, `${request.instruction}\n${domainSpec(domain).scoutFocus}`, request.signal, request.taskText))),
+    Promise.all(request.domains.map((domain) => pickKnowledge(request, domain, `${request.instruction}\n${domainSpec(domain).scoutFocus}\n\n${request.taskText}`))),
+  ]);
   const extraTools = request.hints?.tools() ?? [];
   const requests: AgentRequest[] = request.domains.map((domain, index) => ({
     taskId: request.taskId,
     domain,
     role: "scout",
     instruction: scoutInstruction(request, domain),
-    context: scoutContext(request, domain, likely[index]),
+    context: scoutContext(request, domain, selected[index]!, likely[index]),
     ...(extraTools.length > 0 ? { extraTools } : {}),
     ...profileFields(request.config, request.profile, domain, "scout"),
     ...(request.time ? { time: { ...request.time } } : {}),
@@ -204,6 +230,8 @@ export interface WorkerRequest {
   onUpdate?: (run: AgentRun) => void;
   /** Likely files for the worker's step, and the lookup tool, while the classifier's file hints are on. */
   hints?: FileHinter;
+  /** Picks the relevant sections of long knowledge files, while the classifier's knowledge picks are on. */
+  knowledge?: KnowledgePicker;
   /** Lowers thinking (or the model) for a step the classifier judges simple or trivial. */
   effort?: EffortRouter;
   /** Under a task time budget: the step's time, and who decides on more when it runs out. */
@@ -246,10 +274,9 @@ export async function runWorker(
   request: WorkerRequest,
   run: ProcessRunner = spawnPiProcess,
 ): Promise<WorkerOutcome> {
-  const slices = readAgentKnowledge(request.dataRoots, request.domain);
-  const selected = selectKnowledge(`${request.taskText} ${request.instruction}`, slices);
   const configured = profileFields(request.config, request.profile, request.domain, "worker");
-  const [likely, route] = await Promise.all([
+  const [selected, likely, route] = await Promise.all([
+    pickKnowledge(request, request.domain, `${request.instruction}\n\n${request.taskText}`),
     likelyFor(request.hints, request.instruction, request.signal, request.taskText),
     routeFor(request.effort, request.instruction, { ...(configured.model ? { model: configured.model } : {}), thinking: configured.thinking }, { context: request.taskText, ...(request.signal ? { signal: request.signal } : {}) }),
   ]);
@@ -325,6 +352,8 @@ export interface ReviewerRequest {
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
+  /** Picks the relevant sections of long knowledge files, while the classifier's knowledge picks are on. */
+  knowledge?: KnowledgePicker;
 }
 
 function reviewerContext(request: ReviewerRequest): string {
@@ -390,10 +419,7 @@ export async function runReviewer(
   request: ReviewerRequest,
   run: ProcessRunner = spawnPiProcess,
 ): Promise<ReviewerOutcome> {
-  const selected = selectKnowledge(
-    `${request.taskText} ${request.workerSummary}`,
-    readAgentKnowledge(request.dataRoots, request.domain),
-  );
+  const selected = await pickKnowledge(request, request.domain, `${request.taskText} ${request.workerSummary}`);
   const agentRequest = reviewerAgentRequest(request, selected);
   const attempts = Math.max(1, request.config.workflow.maxAgentRetries + 1);
   let agentRun = await runAgent(agentRequest, run);

package/src/pi/commands.ts

@@ -30,6 +30,8 @@ import { describeRun, runFromLog } from "./run-summary.ts";
 import { modelLookup } from "./tools.ts";
 import { budgetLine, budgetState, parseMinutes, readBudget, setBudget, startClock } from "../state/budget.ts";
 import { qaStillDue } from "../workflow/track.ts";
+import type { GitIsolation } from "../schemas/configuration.ts";
+import { START_FLAG } from "./start-flags.ts";
 
 const HELP = [
   "/bot-lobby                  Open the lobby: tasks, plan, quick fix, metrics (alt+l)",
@@ -37,6 +39,7 @@ const HELP = [
   "/bot-lobby --task [--auto] <request>   Always a task (also when the request begins with a subcommand word)",
   "/bot-lobby --budget 90m <request>   Start a task with a time budget the oracle divides between its agents",
   "/bot-lobby --fast|--full <request>   Start a task on the fast track (straight to the agents it needs) or the full workflow, whatever it reads as",
+  "/bot-lobby --branch|--worktree|--no-branch <request>   Give the task its own git branch, or its own worktree, named after it (or neither), whatever workflow.gitIsolation says",
   "/bot-lobby budget [90m|off]  Show or set this session's task time budget",
   "/bot-lobby status [taskId]  Show the active task",
   "/bot-lobby tasks            List tasks",
@@ -59,13 +62,11 @@ const HELP = [
 /** Subcommands only win when no free-form text follows (so tasks still start). */
 const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "minimize", "restore", "claim", "auto", "start-plan", "switch"]);
 
+/** `Task-Change-Table-Font-27-09-2026`, or an older `TASK-add-login` id. */
 function isTaskId(value: string | undefined): boolean {
-  return Boolean(value && /^TASK-/.test(value));
+  return Boolean(value && /^task-/i.test(value));
 }
 
-/** A task start's leading flags: `--task` (always a task), `--auto`, `--fast`, `--full`, `--budget <time>` (or `--budget=<time>`). */
-const START_FLAG = /^--(task|auto|fast|full)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
-
 export interface ParsedCommand {
   sub: string | undefined;
   rest: string[];
@@ -79,6 +80,8 @@ export interface ParsedCommand {
   track?: "fast" | "full";
   /** `--task`: a task, never routed to the quick-fix agent. */
   task?: boolean;
+  /** `--branch`, `--worktree` or `--no-branch`: the task's git isolation, whatever the config says. */
+  isolation?: GitIsolation;
 }
 
 export function parseCommand(args: string): ParsedCommand {
@@ -86,12 +89,14 @@ export function parseCommand(args: string): ParsedCommand {
   // Leading flags start a task: what follows is its request, even when it begins with a subcommand word
   // (a background session started from the lobby sends `--task [--auto] <request>`).
   let flagged = false;
-  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError" | "track" | "task"> = {};
+  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError" | "track" | "task" | "isolation"> = {};
   for (let match = START_FLAG.exec(trimmed); match; match = START_FLAG.exec(trimmed)) {
     flagged = true;
     if (match[1] === "auto") extras.auto = true;
     else if (match[1] === "task") extras.task = true;
     else if (match[1] === "fast" || match[1] === "full") extras.track = match[1];
+    else if (match[1] === "branch" || match[1] === "worktree") extras.isolation = match[1];
+    else if (match[1] === "no-branch") extras.isolation = "off";
     else if (match[2] !== undefined) {
       const minutes = parseMinutes(match[2]);
       if (minutes) extras.budget = minutes;
@@ -324,7 +329,7 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const { sub, rest, restText, auto, budget, budgetError, track, task } = parseCommand(args ?? "");
+      const { sub, rest, restText, auto, budget, budgetError, track, task, isolation } = parseCommand(args ?? "");
       if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
       if (!sub) {
         if (!restText) {
@@ -332,7 +337,7 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return;
         }
         // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
-        const started = await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}) });
+        const started = await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}), ...(isolation ? { isolation } : {}) });
         if (started === "task") autoOpenLobby();
         return;
       }

package/src/pi/model-support.ts

@@ -131,6 +131,15 @@ export function resolvePanelProfile(config: BotLobbyConfig, member: PanelMember,
   return resolveRunProfile(panelMemberProfile(config, member), kindLabel(member), options);
 }
 
+/**
+ * The model, thinking and time limit a pull request review runs on: QA's, the
+ * agent whose job is judging work, with its custom instructions.
+ */
+export function resolveReviewProfile(config: BotLobbyConfig, options: ResolverOptions): RunProfile {
+  const profile = agentProfile(config, "qa", "reviewer");
+  return resolveRunProfile({ model: profile.model, thinking: profile.thinking, timeoutMs: profile.timeoutMs, ...(profile.instructions ? { instructions: profile.instructions } : {}), ...(profile.fallback ? { fallback: profile.fallback } : {}) }, kindLabel("qa"), 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]> = [

package/src/pi/plan-checklist.ts

@@ -119,6 +119,48 @@ export function planSteps(plan: string): string[] {
   return collectSteps(lines, topBulletItem).slice(0, MAX_PLAN_STEPS);
 }
 
+/** Where a plan's steps section sits, and each of its top-level steps whole (its nested lines included). */
+export interface StepBlocks {
+  /** The section's body: from this line up to (not including) `to`. */
+  from: number;
+  to: number;
+  /** One entry per step, the step's lines as written. */
+  blocks: string[];
+}
+
+/**
+ * The steps of a plan written as a list under a `Steps` heading, each with the
+ * lines that hang under it, so a step can be moved to another plan whole.
+ * Undefined when the plan has no such section (its steps are headings, or
+ * scattered); the list found here counts steps the way `planSteps` does.
+ */
+export function planStepBlocks(plan: string): StepBlocks | undefined {
+  const lines = plan.split("\n");
+  const heading = lines.findIndex((line) => HEADER_LINE.test(line) && STEP_SECTION.test(line));
+  if (heading < 0) return undefined;
+  let to = lines.length;
+  for (let index = heading + 1; index < lines.length; index += 1) {
+    if (HEADER_LINE.test(lines[index]!)) {
+      to = index;
+      break;
+    }
+  }
+  const blocks: string[][] = [];
+  let parent: number | undefined;
+  for (let index = heading + 1; index < to; index += 1) {
+    const line = lines[index]!;
+    const item = sectionItem(line);
+    if (item && !(parent !== undefined && item.indent >= parent)) {
+      blocks.push([line]);
+      parent = item.content;
+      continue;
+    }
+    if (!item && parent !== undefined && line.trim() && indentOf(line) < parent) parent = undefined;
+    if (parent !== undefined && blocks.length > 0) blocks[blocks.length - 1]!.push(line);
+  }
+  return { from: heading + 1, to, blocks: blocks.map((block) => block.join("\n").replace(/\s+$/, "")) };
+}
+
 /* -------------------------------------------------------------------------
  * Step matching. A worker instruction names its step explicitly ("Step 3: ...")
  * or is scored against every step by shared paths, a shared opening phrase and

package/src/pi/route.ts

@@ -90,7 +90,8 @@ export async function startRequest(pi: ExtensionAPI, ctx: ExtensionContext, conf
   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;
+  // `--branch` and `--worktree` are for tasks, so they place the request; `--no-branch` only says what a task would not get.
+  const placed = asTask || start.track || start.approvedPlan || (start.isolation && start.isolation !== "off") || !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;

package/src/pi/settings-ui.ts

@@ -7,16 +7,19 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Container, type Component, type Focusable, fuzzyFilter, getKeybindings, Input, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
 import {
+  GIT_ISOLATIONS,
   JEV_HOSTS,
   INHERIT_MODEL,
   isThinkingLevel,
   LOBBY_PANELS,
   PLANNING_ROUND_CHOICES,
   SCOUT_THINKING,
+  SPLIT_PLAN_CHOICES,
   SUBAGENT_KINDS,
   type AgentModelConfig,
   type BotLobbyConfig,
   type ClassifierFeature,
+  type GitIsolation,
   type JevHostName,
   type LobbyPanel,
   type SubagentKind,
@@ -451,16 +454,30 @@ export function nextRoundLimit(current: number): number {
   return PLANNING_ROUND_CHOICES.find((choice) => choice > current) ?? 0;
 }
 
+/** `over 8 steps`, or `never` for 0. */
+export function splitLimitLabel(limit: number): string {
+  return limit > 0 ? `over ${limit} steps` : "never";
+}
+
+/** The next step count in the menu's cycle (6, 8, 10, 12, never); a hand-edited value rejoins it. */
+export function nextSplitLimit(current: number): number {
+  const index = SPLIT_PLAN_CHOICES.indexOf(current as (typeof SPLIT_PLAN_CHOICES)[number]);
+  if (index >= 0) return SPLIT_PLAN_CHOICES[(index + 1) % SPLIT_PLAN_CHOICES.length]!;
+  return SPLIT_PLAN_CHOICES.find((choice) => choice > current) ?? 0;
+}
+
 /** On/off settings for the lobby, and the planning round limit; enter flips or cycles one and saves it. Key rebinding stays in the file (lobby.keys). */
 async function editLobby(ctx: ExtensionContext): Promise<void> {
   for (;;) {
     const config = loadConfig();
     const items: SelectItem[] = LOBBY_SWITCHES.map((entry) => ({ value: entry.id, label: entry.label, description: `${lobbySwitch(config, entry.id) ? "on" : "off"} · ${entry.help}` }));
     items.push({ value: "rounds", label: "Planning rounds", description: `${roundLimitLabel(config.lobby.maxPlanningRounds)} · enter cycles 2, 3, 5, 8, unlimited; the last round the oracle settles alone` });
+    items.push({ value: "split", label: "Split long plans", description: `${splitLimitLabel(config.lobby.splitPlanAbove)} · saving a plan with more steps offers to split it into up to 5 tasks · enter cycles 6, 8, 10, 12, never` });
     items.push({ value: "back", label: "Back", description: `keys: lobby.keys in ${globalConfigPath()}` });
     const choice = await pick(ctx, "bot-lobby settings · Lobby", items);
     if (!choice || choice === "back") return;
     if (choice === "rounds") saveConfig({ ...config, lobby: { ...config.lobby, maxPlanningRounds: nextRoundLimit(config.lobby.maxPlanningRounds) } });
+    else if (choice === "split") saveConfig({ ...config, lobby: { ...config.lobby, splitPlanAbove: nextSplitLimit(config.lobby.splitPlanAbove) } });
     else saveConfig(toggleLobbySwitch(config, choice as LobbySwitch));
   }
 }
@@ -473,6 +490,7 @@ function lobbySummary(config: BotLobbyConfig): string {
     config.lobby.mouse ? "mouse" : "no mouse",
     ...(config.lobby.miniLine ? [] : ["no status line"]),
     `planning: ${roundLimitLabel(config.lobby.maxPlanningRounds)}`,
+    `split plans ${splitLimitLabel(config.lobby.splitPlanAbove)}`,
     ...(config.lobby.issues ? ["issues tab"] : []),
     ...(hidden.length > 0 ? [`hidden: ${hidden.join(", ")}`] : []),
   ].join(" · ");
@@ -487,9 +505,29 @@ export const CLASSIFIER_FEATURE_ITEMS: ReadonlyArray<{ id: ClassifierFeature; la
   { id: "answers", label: "Obvious answers", help: "a panel question whose recommended option the conversation already makes clearly right is answered for you (listed under Assumptions)" },
   { id: "triage", label: "Task triage", help: "a new task's size, domains and research need reach the Master as hints; a quick fix that is really a task is held for you" },
   { id: "effort", label: "Effort routing", help: "a simple step runs one thinking level lower, a trivial one on the cheaper model below; a routed run that falls short runs again on your settings" },
+  { id: "review", label: "Pull request read", help: "the Git tab's quick read of a pull request: its size, and how likely it is risky, security-relevant, breaking or untested, before an agent reviews it" },
+  { id: "knowledge", label: "Relevant knowledge", help: "when an agent's knowledge, standards or decisions file is too long for its prompt, Jev picks the sections that bear on the step, and the agent is told where the rest is" },
   { id: "files", label: "File hints", help: "scouts, workers, quick fixes and the planning panel start with the files most likely needed, and can look more up with find_relevant_files" },
 ];
 
+/** What each git isolation means, for the settings menu. */
+const GIT_ISOLATION_HELP: Record<GitIsolation, string> = {
+  off: "tasks work in the folder you started them in",
+  branch: "each new task gets a git branch named after it, checked out in the working folder",
+  worktree: "each new task gets its own worktree and branch, named after it: every agent runs there, apart from your checkout",
+};
+
+/** The next git isolation in the menu's cycle (off, branch, worktree). */
+export function nextGitIsolation(current: GitIsolation): GitIsolation {
+  return GIT_ISOLATIONS[(GIT_ISOLATIONS.indexOf(current) + 1) % GIT_ISOLATIONS.length]!;
+}
+
+/** `branch · each new task gets…`, for the settings menu; `--branch`, `--worktree` and `--no-branch` decide for one task. */
+export function gitSummary(config: BotLobbyConfig): string {
+  const isolation = config.workflow.gitIsolation;
+  return `${isolation} · ${GIT_ISOLATION_HELP[isolation]} · enter cycles ${GIT_ISOLATIONS.join(", ")}`;
+}
+
 /** The next Jev host in the menu's cycle. */
 export function nextJevHost(current: JevHostName): JevHostName {
   return JEV_HOSTS[(JEV_HOSTS.indexOf(current) + 1) % JEV_HOSTS.length]!;
@@ -605,12 +643,14 @@ export async function openSettings(pi: ExtensionAPI, ctx: ExtensionContext): Pro
   for (;;) {
     const config = loadConfig();
     const items: SelectItem[] = SETTINGS_KINDS.map((kind) => ({ value: kind, label: kindLabel(kind), description: entryDescription(kind, entryView(config, kind)) }));
+    items.push({ value: "git", label: "Git isolation", description: gitSummary(config) });
     items.push({ value: "lobby", label: "Lobby", description: lobbySummary(config) });
     items.push({ value: "classifier", label: "Classifier (Jev)", description: classifierSummary(config, authStatus(ctx)) });
     items.push({ value: "close", label: "Close" });
     const choice = await pick(ctx, "bot-lobby settings", items);
     if (!choice || choice === "close") return;
-    if (choice === "lobby") await editLobby(ctx);
+    if (choice === "git") saveConfig({ ...config, workflow: { ...config.workflow, gitIsolation: nextGitIsolation(config.workflow.gitIsolation) } });
+    else if (choice === "lobby") await editLobby(ctx);
     else if (choice === "classifier") await editClassifier(ctx);
     else await editEntry(pi, ctx, choice as SettingsKind);
   }

package/src/pi/start-flags.ts

@@ -0,0 +1,14 @@
+/**
+ * The flags that lead a task's request: `--task` (always a task), `--auto`,
+ * `--fast`, `--full`, `--branch`, `--worktree`, `--no-branch` and
+ * `--budget <time>` (or `--budget=<time>`). The command parses them; a session
+ * started from the lobby is named from what follows them.
+ */
+export const START_FLAG = /^--(task|auto|fast|full|branch|worktree|no-branch)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
+
+/** The request without its leading flags. */
+export function stripStartFlags(text: string): string {
+  let rest = text.trim();
+  for (let match = START_FLAG.exec(rest); match; match = START_FLAG.exec(rest)) rest = rest.slice(match[0].length);
+  return rest.trim();
+}

package/src/pi/start-task.ts

@@ -9,17 +9,19 @@ import { createTask, taskRequest, type Task, type TaskTrack, type TaskTriage, ty
 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 { createTaskDir, ensureProjectStructure, loadTask, 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";
 import { setAutoMode } from "../state/auto.ts";
-import { loadPlannedTask, markPlannedTaskStarted, plannedTaskRequest } from "../state/backlog.ts";
+import { listPlannedTasks, loadPlannedTask, markPlannedTaskStarted, plannedTaskRequest, type PlannedTask } from "../state/backlog.ts";
 import { triageFor } from "../classifier/instance.ts";
 import { freshContextOn, markContext } from "./fresh-context.ts";
 import { setBudget } from "../state/budget.ts";
+import { createWorkspace, gitLine } from "../execution/workspace.ts";
+import type { GitIsolation } from "../schemas/configuration.ts";
 
 function uniqueTaskId(root: string, configDir: string, request: string): string {
   const base = nextTaskId(request);
@@ -62,6 +64,7 @@ export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: bo
     ...(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).`] : []),
+    ...(task.git ? [gitLine(task.git)] : []),
     "",
   ];
   if (track?.path === "fast") return [...head, ...fastSteps(track)].join("\n");
@@ -77,6 +80,23 @@ export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: bo
   ].join("\n");
 }
 
+/**
+ * Give the task its git branch or worktree, named after it. Any failure (no
+ * repository, no commits, a refused checkout) is said once and the task runs
+ * without: git must never stop a task from starting.
+ */
+async function giveWorkspace(ctx: ExtensionContext, root: string, configDir: string, task: Task, isolation: GitIsolation): Promise<void> {
+  if (isolation === "off") return;
+  const made = await createWorkspace({ cwd: ctx.cwd, root, configDir, name: task.id, mode: isolation });
+  if (typeof made === "string") {
+    lobbyFeed.log("LOBBY", `${task.id} runs without its own ${isolation} — ${made}`, "warning");
+    ctx.ui.notify(`bot-lobby: ${task.id} runs without its own ${isolation} — ${made}`, "warning");
+    return;
+  }
+  task.git = made;
+  lobbyFeed.log("LOBBY", made.mode === "worktree" ? `${task.id}: worktree ${made.path} on branch ${made.branch}` : `${task.id}: on branch ${made.branch}${made.from ? ` (from ${made.from})` : ""}`, "success");
+}
+
 /**
  * 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
@@ -98,6 +118,8 @@ export interface StartOptions {
   triage?: TaskTriage;
   /** The oracle sent this request to the team after the classifier read it as a quick fix. */
   routed?: boolean;
+  /** `--branch`, `--worktree` or `--no-branch`: whether this task gets a git branch or worktree of its own; `workflow.gitIsolation` when absent. */
+  isolation?: GitIsolation;
 }
 
 export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, request: string, options: StartOptions = {}): Promise<Task | undefined> {
@@ -120,12 +142,13 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   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");
+  await giveWorkspace(ctx, root, configDir, task, options.isolation ?? config.workflow.gitIsolation);
   saveTask(root, configDir, task);
   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.
-  if (!pi.getSessionName()) pi.setSessionName(task.title);
+  // A session that starts a task is named after it (its friendly name), so /resume and the lobby list it by name.
+  if (!pi.getSessionName()) pi.setSessionName(task.id);
   applyStatus(ctx, root, configDir);
   await applyMasterModel(pi, ctx, loadConfig());
   ctx.ui.notify(`bot-lobby ${task.id} started`, "info");
@@ -136,18 +159,46 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   return task;
 }
 
+/**
+ * The parts of a split plan that this one builds on and that are not finished:
+ * still pending, dropped, or started but not completed. Empty for a plan that
+ * was not split, or whose earlier parts are done (or gone).
+ */
+export function unfinishedBefore(root: string, configDir: string, plan: PlannedTask): string[] {
+  const split = plan.split;
+  if (!split || split.after.length === 0) return [];
+  const siblings = listPlannedTasks(root, configDir).filter((entry) => entry.split?.group === split.group);
+  return split.after.flatMap((number) => {
+    const sibling = siblings.find((entry) => entry.split?.part === number);
+    if (!sibling) return [];
+    const label = `part ${number} (${split.titles[number - 1] ?? sibling.id})`;
+    if (sibling.status === "pending") return [`${label} has not been started`];
+    const task = sibling.startedTaskId ? loadTask(root, configDir, sibling.startedTaskId) : undefined;
+    if (!task || task.state === "completed") return [];
+    return [`${label} is ${task.state === "abandoned" ? "abandoned" : "not finished"}`];
+  });
+}
+
 /**
  * Start a task saved from the planning panel in this session. The user
  * already agreed its plan, so the task carries it as approved and its
- * proposal goes through without asking. Returns the task, or a reason.
+ * proposal goes through without asking. A part of a split plan that builds on
+ * parts not yet finished starts anyway, with a warning: the order is the
+ * user's to keep. Returns the task, or a reason.
  */
 export async function startPlannedTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, planId: string, options: { auto?: boolean } = {}): Promise<Task | string> {
   const root = detectProjectRoot(ctx.cwd, configDir);
   const plan = loadPlannedTask(root, configDir, planId);
   if (!plan) return `no planned task ${planId}`;
   if (plan.status !== "pending") return `${planId} was already started${plan.startedTaskId ? ` as ${plan.startedTaskId}` : ""}`;
+  const waiting = unfinishedBefore(root, configDir, plan);
   const task = await startTask(pi, ctx, configDir, plannedTaskRequest(plan), { approvedPlan: plan.id, title: plan.title, ...(options.auto ? { auto: true } : {}) });
   if (!task) return `this session already drives a task; finish or cancel it first`;
   markPlannedTaskStarted(root, configDir, plan.id, task.id);
+  if (waiting.length > 0) {
+    const warning = `${plan.id} builds on ${waiting.join("; ")} — started anyway`;
+    lobbyFeed.log("LOBBY", warning, "warning");
+    ctx.ui.notify(`bot-lobby: ${warning}`, "warning");
+  }
   return task;
 }

package/src/pi/tools.ts

@@ -5,7 +5,7 @@ import { Type } from "typebox";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { ProcessRunner } from "../execution/pi-runner.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
-import { classifier, effortFor, hintsFor, triageFor } from "../classifier/instance.ts";
+import { classifier, effortFor, hintsFor, knowledgeFor, triageFor } from "../classifier/instance.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
 import { whileAsking } from "../state/budget.ts";
@@ -119,11 +119,13 @@ export function workflowDeps(
     onUpdate,
     runProcess,
     hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
+    knowledge: knowledgeFor(),
     classifier: classifier(),
     triage: (request, triageSignal) => triageFor({ cwd: ctx.cwd, root, configDir }, request, triageSignal),
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
     // Time spent waiting on the user is not the task's: its budget clock waits too.
-    ask: async (question) => (hasUI ? whileAsking(() => ctx.ui.input(question)) : undefined),
+    // A free-text answer may run to several lines (Shift+Enter), so it is asked in the multi-line editor.
+    ask: async (question) => (hasUI ? whileAsking(() => ctx.ui.editor(question)) : undefined),
     choose: async (title, options) => (hasUI ? whileAsking(() => ctx.ui.select(title, options)) : undefined),
     // An agent's own questions (the designer's), relayed as the questionnaire.
     ...(hasUI ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => askUser(questions, ctx, askSignal, from)) } : {}),