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

package/src/schemas/configuration.ts

@@ -55,6 +55,18 @@ export type LobbyAgentKind = "quickfix" | "planner";
 /** Settings kinds a workflow run (domain + role) can draw from. */
 export type WorkflowProfileKind = Domain | "scout" | "researcher";
 
+/**
+ * Whether a new task gets a git branch of its own (`branch`: created and
+ * checked out in the working folder) or a worktree of its own (`worktree`: a
+ * second checkout every agent of the task runs in), named after the task.
+ */
+export const GIT_ISOLATIONS = ["off", "branch", "worktree"] as const;
+export type GitIsolation = (typeof GIT_ISOLATIONS)[number];
+
+export function isGitIsolation(value: unknown): value is GitIsolation {
+  return typeof value === "string" && (GIT_ISOLATIONS as readonly string[]).includes(value);
+}
+
 export interface WorkflowConfig {
   maxReviewIterations: number;
   maxParallelScouts: number;
@@ -82,6 +94,8 @@ export interface WorkflowConfig {
   briefCheck: boolean;
   /** A new request that one agent can do alone goes to the quick-fix agent once the oracle confirms; false makes every request a task. */
   routeQuickFixes: boolean;
+  /** A new task gets a git branch or worktree of its own, named after it; `--branch` and `--worktree` decide for one task. */
+  gitIsolation: GitIsolation;
 }
 
 export interface KnowledgeConfig {
@@ -129,10 +143,15 @@ export interface LobbyConfig {
    * round skips the seats and asks nothing; later replies only revise. 0 = unlimited.
    */
   maxPlanningRounds: number;
+  /**
+   * A plan with more steps than this is offered to be split into up to five
+   * tasks when it is saved (the oracle proposes, the user decides); 0 = never.
+   */
+  splitPlanAbove: number;
 }
 
 /** Decisions the classifier can make, each switched on or off on its own. */
-export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort"] as const;
+export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge"] as const;
 export type ClassifierFeature = (typeof CLASSIFIER_FEATURES)[number];
 
 /** Hosts that serve Jev behind the same System One API; `auto` takes OpenCode's free Jev when pi holds an OpenCode key, else TypeSafe. */
@@ -151,6 +170,8 @@ export interface ClassifierThresholds {
   autoAnswerMargin: number;
   /** A file is a likely file at this relevance. */
   fileRelevantAt: number;
+  /** A section of a knowledge file that is over the prompt budget stays in at this relevance. */
+  knowledgeRelevantAt: number;
   /** A step scored simple at this confidence runs one thinking level lower. */
   simpleAt: number;
   /** A step scored trivial at this confidence runs on the cheaper model. */
@@ -224,6 +245,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     fastTrack: true,
     briefCheck: true,
     routeQuickFixes: true,
+    gitIsolation: "off",
   },
   knowledge: {
     compactionThreshold: 20000,
@@ -241,6 +263,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     mouse: true,
     miniLine: true,
     maxPlanningRounds: 5,
+    splitPlanAbove: 8,
   },
   classifier: {
     enabled: false,
@@ -248,13 +271,14 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     model: "",
     baseUrl: "",
     timeoutMs: 4000,
-    features: { seats: true, answers: true, files: true, triage: true, effort: true },
+    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true },
     thresholds: {
       seatAt: 0.35,
       reseatReadyAt: 0.6,
       autoAnswerAt: 0.9,
       autoAnswerMargin: 0.5,
       fileRelevantAt: 0.5,
+      knowledgeRelevantAt: 0.4,
       simpleAt: 0.7,
       trivialAt: 0.8,
       quickFixAt: 0.7,
@@ -269,6 +293,9 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
 /** Choices the settings menu cycles through for the planning round limit; 0 = unlimited. */
 export const PLANNING_ROUND_CHOICES = [2, 3, 5, 8, 0] as const;
 
+/** Choices the settings menu cycles through for the step count past which a saved plan is offered a split; 0 = never. */
+export const SPLIT_PLAN_CHOICES = [6, 8, 10, 12, 0] as const;
+
 function positive(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
 }
@@ -299,7 +326,7 @@ function flag(value: unknown, fallback: boolean): boolean {
 }
 
 function normalizeLobby(value: unknown): LobbyConfig {
-  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: unknown; miniLine?: unknown; maxPlanningRounds?: unknown } | undefined;
+  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: unknown; miniLine?: unknown; maxPlanningRounds?: unknown; splitPlanAbove?: unknown } | undefined;
   const defaults = DEFAULT_CONFIG.lobby;
   const panel = Array.isArray(source?.planningPanel)
     ? [...new Set(source.planningPanel.filter((entry): entry is PanelMember => typeof entry === "string" && isPanelMember(entry)))]
@@ -316,6 +343,7 @@ function normalizeLobby(value: unknown): LobbyConfig {
     mouse: flag(source?.mouse, defaults.mouse),
     miniLine: flag(source?.miniLine, defaults.miniLine),
     maxPlanningRounds: roundLimit(source?.maxPlanningRounds, defaults.maxPlanningRounds),
+    splitPlanAbove: roundLimit(source?.splitPlanAbove, defaults.splitPlanAbove),
   };
 }
 
@@ -370,6 +398,7 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
   workflow.fastTrack = workflow.fastTrack !== false;
   workflow.briefCheck = workflow.briefCheck !== false;
   workflow.routeQuickFixes = workflow.routeQuickFixes !== false;
+  workflow.gitIsolation = isGitIsolation(workflow.gitIsolation) ? workflow.gitIsolation : DEFAULT_CONFIG.workflow.gitIsolation;
   workflow.taskBudgetMinutes = typeof workflow.taskBudgetMinutes === "number" && workflow.taskBudgetMinutes > 0 ? Math.min(24 * 60, Math.round(workflow.taskBudgetMinutes)) : 0;
   const knowledge = { ...DEFAULT_CONFIG.knowledge, ...(src.knowledge as Partial<KnowledgeConfig> | undefined) };
   const srcAgents = (src.agents ?? {}) as Partial<BotLobbyConfig["agents"]>;

package/src/schemas/task.ts

@@ -158,6 +158,19 @@ export interface QaWaiver {
   open: string[];
 }
 
+/** The branch (or worktree and branch) a task works on, when git isolation was on as it started. */
+export interface TaskGit {
+  mode: "branch" | "worktree";
+  /** Named after the task. */
+  branch: string;
+  /** What the working folder stood on when the task started: a branch name, or `detached at 1a2b3c4`. */
+  from?: string;
+  /** The commit it branched from. */
+  base?: string;
+  /** worktree: the folder every agent of the task runs in. */
+  path?: string;
+}
+
 export interface Task {
   id: string;
   title: string;
@@ -197,6 +210,8 @@ export interface Task {
   extraReviewRounds?: number;
   /** Set only by the user: the work is accepted without a QA pass, so the task may complete. */
   qaWaiver?: QaWaiver;
+  /** The git branch (or worktree) made for this task, when isolation was on as it started. */
+  git?: TaskGit;
 }
 
 export function createTask(

package/src/state/backlog.ts

@@ -18,6 +18,19 @@ export interface IssueRef {
   url?: string;
 }
 
+/** What a task saved from a split plan knows of the others: it is one part of a plan that became several tasks. */
+export interface SplitInfo {
+  /** Shared by every part of one plan. */
+  group: string;
+  /** This part's number (from 1) and how many parts there are. */
+  part: number;
+  of: number;
+  /** The title of every part, in order. */
+  titles: string[];
+  /** Parts (by number) that come before this one and should be finished first. */
+  after: number[];
+}
+
 export interface PlannedTask {
   id: string;
   title: string;
@@ -29,6 +42,8 @@ export interface PlannedTask {
   issue?: IssueRef;
   /** The bot-lobby task started from this entry. */
   startedTaskId?: string;
+  /** Set when the plan was split into several tasks and this is one of them. */
+  split?: SplitInfo;
 }
 
 export function backlogDir(root: string, configDir: string): string {
@@ -48,7 +63,7 @@ function isPlannedTask(value: unknown): value is PlannedTask {
 export function savePlannedTask(
   root: string,
   configDir: string,
-  input: { title: string; brief: string; issue?: IssueRef },
+  input: { title: string; brief: string; issue?: IssueRef; split?: SplitInfo },
   now = new Date(),
 ): PlannedTask {
   const title = input.title.trim() || "planned task";
@@ -58,7 +73,7 @@ export function savePlannedTask(
   let id = base;
   for (let n = 2; existsSync(entryPath(root, configDir, id)); n++) id = `${base}-${n}`;
   const at = now.toISOString();
-  const entry: PlannedTask = { id, title, brief, createdAt: at, updatedAt: at, status: "pending", ...(input.issue ? { issue: input.issue } : {}) };
+  const entry: PlannedTask = { id, title, brief, createdAt: at, updatedAt: at, status: "pending", ...(input.issue ? { issue: input.issue } : {}), ...(input.split ? { split: input.split } : {}) };
   writeFileEnsured(entryPath(root, configDir, id), JSON.stringify(entry, null, 2));
   return entry;
 }
@@ -109,8 +124,16 @@ export function discardPlannedTask(root: string, configDir: string, id: string):
   rmSync(entryPath(root, configDir, id), { force: true });
 }
 
-/** The request a started task carries: the agreed plan, plus the issue it came from. */
+/** `Part 2 of 3 of one plan…` and the other parts' titles, for a task that is one part of a split plan. */
+export function splitLine(split: SplitInfo): string {
+  const others = split.titles.map((title, index) => `${index + 1}. ${title}${index + 1 === split.part ? " (this task)" : ""}`).join("; ");
+  const before = split.after.length > 0 ? ` It builds on ${split.after.map((part) => `part ${part}`).join(" and ")}, which should be done first.` : "";
+  return `This is part ${split.part} of ${split.of} of one plan that was split into separate tasks: ${others}.${before} Do only this part; the others are their own tasks.`;
+}
+
+/** The request a started task carries: the agreed plan, plus the issue it came from, plus where it sits in a split plan. */
 export function plannedTaskRequest(entry: PlannedTask): string {
   const source = entry.issue ? `\n\nFrom GitHub issue #${entry.issue.number}: ${entry.issue.title}${entry.issue.url ? ` (${entry.issue.url})` : ""}` : "";
-  return `${entry.title}\n\nAgreed plan (from the planning session):\n${entry.brief}${source}`;
+  const part = entry.split ? `\n\n${splitLine(entry.split)}` : "";
+  return `${entry.title}${part}\n\nAgreed plan (from the planning session):\n${entry.brief}${source}`;
 }

package/src/state/metrics.ts

@@ -33,7 +33,7 @@ export interface MetricRecord {
   cost?: number;
   taskId?: string;
   stalled?: boolean;
-  /** Classifier calls: what the call decided (seats, answers, files, triage, effort, test). */
+  /** Classifier calls: what the call decided (seats, answers, files, triage, effort, review, knowledge, test). */
   purpose?: string;
   /** A run the classifier routed down: the configured profile it came from. */
   routedFrom?: string;
@@ -49,7 +49,7 @@ export interface ClassifierSummary {
   p90Ms: number;
   /** Tokens Jev read across every call. */
   input: number;
-  /** Calls per decision (seats, answers, files, triage, effort, test). */
+  /** Calls per decision (seats, answers, files, triage, effort, review, knowledge, test). */
   byPurpose: Record<string, number>;
   seatRunsSkipped: number;
   questionsAnswered: number;

package/src/state/persistence.ts

@@ -15,6 +15,7 @@ import {
 } from "../knowledge/paths.ts";
 import { DEFAULT_KNOWLEDGE_CONTENT, ensureFile, readFileOr, writeFileEnsured } from "../knowledge/store.ts";
 import { forgetCached, forgetCachedUnder, readJsonCached } from "./file-cache.ts";
+import { taskName } from "../text.ts";
 
 /** Idempotently create the full knowledge + tasks layout with seed files. */
 export function ensureProjectStructure(root: string, configDir: string): void {
@@ -235,13 +236,12 @@ export function taskSlug(request: string, max = 40): string {
 }
 
 /**
- * Task id from the request (`TASK-<slug>`); requests with no usable slug fall
- * back to the timestamped `TASK-task-<timestamp>` form callers already suffix.
+ * Task id from the request: its friendly name, `Task-<Words>-<DD-MM-YYYY>`
+ * (`Task-Change-Table-Font-27-09-2026`); a request with no words is
+ * `Task-Untitled-<date>`. Callers add a `-2`, `-3`… suffix when it is taken.
  */
 export function nextTaskId(request: string, now = new Date()): string {
-  const slug = taskSlug(request);
-  if (slug.length > 0) return `TASK-${slug}`;
-  return `TASK-task-${now.toISOString().replace(/[-:T]/g, "").slice(0, 14)}`;
+  return taskName(request, now);
 }
 
 /** Files that make up a task's temporary working state (§20). */

package/src/text.ts

@@ -57,6 +57,44 @@ export function shortTitle(request: string, maxWords = 3): string {
   return (content.length > 0 ? content : words).slice(0, maxWords).join(" ").replace(/[:;,]+$/, "");
 }
 
+/** Words a task's name leaves out: they join the words that matter without being any of them. */
+const NAME_CONNECTORS = new Set(["and", "or", "but", "with", "without", "on", "in", "at", "of", "by", "from", "into", "so", "as", "is", "are", "be", "it", "its", "that", "this", "then", "also", "just", "some"]);
+
+/** `27-09-2026`: the local date as day-month-year, as task names carry it. */
+export function dateStamp(now: Date): string {
+  return `${String(now.getDate()).padStart(2, "0")}-${String(now.getMonth() + 1).padStart(2, "0")}-${now.getFullYear()}`;
+}
+
+/**
+ * The first content words of a request as one name part, each capitalised and
+ * joined by dashes (`Change-Table-Font`): at most `maxWords` words and
+ * `maxChars` characters, cut between words. Empty when the request has no
+ * letters or digits.
+ */
+export function nameWords(request: string, maxWords = 5, maxChars = 36): string {
+  // Connectors (`and`, `on`, `with`…) say little in a name and must not fill its few slots or end it.
+  const words = shortTitle(request, maxWords * 3)
+    .split(/[^\p{L}\p{N}]+/u)
+    .filter((word) => word.length > 0 && !NAME_CONNECTORS.has(word.toLowerCase()))
+    .map((word) => word.charAt(0).toLocaleUpperCase() + word.slice(1))
+    .slice(0, maxWords);
+  const kept: string[] = [];
+  for (const word of words) {
+    if ([...kept, word].join("-").length > maxChars && kept.length > 0) break;
+    kept.push(word);
+  }
+  return kept.join("-").slice(0, maxChars).replace(/-+$/, "");
+}
+
+/**
+ * A task's friendly name: `Task-Change-Table-Font-27-09-2026`, from its
+ * request (or title) and the day it started. It is the task's id, the name of
+ * the git branch it works on and of the session that drives it.
+ */
+export function taskName(request: string, now = new Date()): string {
+  return `Task-${nameWords(request) || "Untitled"}-${dateStamp(now)}`;
+}
+
 /** Headings that only label a section (`### Objective`), not name the work. */
 const LABEL_HEADING = /^#{1,6}\s*(objective|goal|goals|summary|overview|task|request|context|background|description|plan)\s*:?\s*$/i;
 

package/src/workflow/workflow.ts

@@ -55,12 +55,14 @@ import { pingApproval } from "../pi/notify.ts";
 import { describeRun, runLogEntry } from "../pi/run-summary.ts";
 import { nextStates } from "./transitions.ts";
 import type { FileHinter } from "../classifier/files.ts";
+import type { KnowledgePicker } from "../classifier/knowledge.ts";
 import type { Classifier } from "../classifier/classifier.ts";
 import type { EffortRouter } from "../classifier/effort.ts";
 import { answerClarify } from "../classifier/triage.ts";
 import { appendMetrics, metricFromRun } from "../state/metrics.ts";
 import { markCommentsAddressed, pendingComments, readPlanComments } from "../state/comments.ts";
 import { fastNext, onFastTrack, parseRoster, qaRequired, qaStillDue, qaTookPart, rosterWords, trackSummary } from "./track.ts";
+import { missingWorktree, taskCwd } from "../execution/workspace.ts";
 
 export const ORCHESTRATE_ACTIONS = [
   "clarify",
@@ -140,6 +142,8 @@ export interface WorkflowDeps {
   runProcess?: ProcessRunner;
   /** Likely files for scouts and workers, while the classifier's file hints are on. */
   hints?: FileHinter;
+  /** Picks the relevant sections of long knowledge files for scouts, workers and the QA gate, while the classifier's knowledge picks are on. */
+  knowledge?: KnowledgePicker;
   /** Answers a clarify question whose recommended option is clearly right, when it is on. */
   classifier?: Classifier;
   /** Re-reads a request after an amendment (the task's triage), when the classifier is on. */
@@ -338,6 +342,7 @@ async function handleScout(task: Task, params: OrchestrateParams, deps: Workflow
       signal: deps.signal,
       onUpdate: deps.onUpdate,
       ...(deps.hints ? { hints: deps.hints } : {}),
+      ...(deps.knowledge ? { knowledge: deps.knowledge } : {}),
       ...(deps.effort ? { effort: deps.effort } : {}),
     },
     deps.runProcess ?? spawnPiProcess,
@@ -677,6 +682,7 @@ function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instructi
     signal: deps.signal,
     onUpdate: deps.onUpdate,
     ...(deps.hints ? { hints: deps.hints } : {}),
+    ...(deps.knowledge ? { knowledge: deps.knowledge } : {}),
     ...(deps.effort ? { effort: deps.effort } : {}),
   };
 }
@@ -1105,6 +1111,7 @@ function qaRequest(deps: WorkflowDeps, task: Task, diff: string, instruction?: s
     profile: deps.profile,
     signal: deps.signal,
     onUpdate: deps.onUpdate,
+    ...(deps.knowledge ? { knowledge: deps.knowledge } : {}),
   };
 }
 
@@ -1680,9 +1687,13 @@ export async function runWorkflowAction(params: OrchestrateParams, deps: Workflo
   if (!handler) {
     return { ok: false, taskId: task.id, state: task.state, message: `Unknown action "${params.action}".` };
   }
+  const gone = missingWorktree(task);
+  if (gone && params.action !== "status") return { ok: false, taskId: task.id, state: task.state, message: `Rejected: ${gone}` };
   const finished = new Map<string, AgentRun>();
   const tracked: WorkflowDeps = {
     ...deps,
+    // Every agent, diff and desk of a task with its own worktree works there.
+    cwd: taskCwd(task, deps.cwd),
     onUpdate: (run) => {
       if (run.status !== "running") finished.set(run.runId, run);
       deps.onUpdate?.(run);