@a-t-h-i/bot-lobby 0.6.3 → 0.6.5

package/src/classifier/triage.ts

@@ -48,6 +48,15 @@ function sizeQuestion(subject: string) {
   return score(`How big is the change ${subject} asks for, judged by what it would take to build and verify in this repository?`, SIZE_LEVELS);
 }
 
+/** Whether one agent can just do it: the quick fix or the team. */
+function soloQuestion(subject: string) {
+  return noul(
+    `Could one engineer do ${subject} alone, right away — in one file or one area of the code — with no contract to agree between frontend and backend, no unfamiliar codebase to survey first, no risky change (security, data, payments, migrations) and no decision the user must make first?`,
+    "Yes: one person can just do it now, even if it is a rich piece of work in one place.",
+    "No: it needs a team — several areas, a survey of the codebase, a plan to agree, or review before it lands.",
+  );
+}
+
 export function triageRequest(input: TriageInput): SystemOneRequest {
   const questions: SystemOneRequest["questions"] = {
     size: sizeQuestion("`request`"),
@@ -62,6 +71,7 @@ export function triageRequest(input: TriageInput): SystemOneRequest {
       "No: a competent engineer could build it as written, deciding details from the codebase.",
     ),
     kind: choice("What kind of work does `request` ask for?", TRIAGE_KINDS),
+    solo: soloQuestion("`request`"),
   };
   for (const { domain, owns } of input.domains) {
     questions[`domain_${domain}`] = noul(`Does building \`request\` require changes in this area: ${owns}?`);
@@ -85,12 +95,14 @@ export async function triageTask(classifier: Classifier, input: TriageInput, sig
     if (probability !== undefined) domains[domain] = probability;
   }
   const kind = choiceOf(result.answers, "kind");
+  const solo = yesOf(result.answers, "solo");
   return {
     size: TRIAGE_SIZES[Math.max(0, Math.min(TRIAGE_SIZES.length - 1, size.level))]!,
     sizeConfidence: size.confidence,
     domains,
     research: yesOf(result.answers, "needs_research") ?? 0,
     ambiguous: yesOf(result.answers, "ambiguous") ?? 0,
+    ...(solo !== undefined ? { solo } : {}),
     ...(kind ? { kind: kind.choice, kindProbability: kind.probability } : {}),
     at: new Date().toISOString(),
   };
@@ -131,20 +143,25 @@ export async function triageWithContext(classifier: Classifier, scope: FileScope
   return files.length > 0 ? { ...triage, likelyFiles: files } : triage;
 }
 
-/** The size of a quick fix prompt, or undefined when the classifier is off or fails. */
-export async function quickFixSize(classifier: Classifier, prompt: string, signal?: AbortSignal): Promise<{ size: TriageSize; confidence: number } | undefined> {
+/**
+ * The size of a quick fix prompt, and how likely one engineer can do it alone,
+ * or undefined when the classifier is off or fails. A large prompt is held as
+ * a task unless it is still one engineer's work (a rich page in one file).
+ */
+export async function quickFixSize(classifier: Classifier, prompt: string, signal?: AbortSignal): Promise<{ size: TriageSize; confidence: number; solo?: number } | undefined> {
   if (!classifier.enabled("triage")) return undefined;
-  const largeAt = classifier.config.thresholds.quickFixLargeAt;
-  const result = await classifier.ask("triage", { state: { prompt: clip(prompt, 6000) }, questions: { size: sizeQuestion("`prompt`") } }, {
+  const { quickFixLargeAt: largeAt, quickFixAt } = classifier.config.thresholds;
+  const result = await classifier.ask("triage", { state: { prompt: clip(prompt, 6000) }, questions: { size: sizeQuestion("`prompt`"), solo: soloQuestion("`prompt`") } }, {
     ...(signal ? { signal } : {}),
     saved: (answers) => {
       const sized = scoreOf(answers, "size");
-      return sized && sized.level >= TRIAGE_SIZES.length - 1 && sized.confidence >= largeAt ? 1 : 0;
+      return sized && sized.level >= TRIAGE_SIZES.length - 1 && sized.confidence >= largeAt && (yesOf(answers, "solo") ?? 0) < quickFixAt ? 1 : 0;
     },
   });
   const size = scoreOf(result?.answers, "size");
   if (!size) return undefined;
-  return { size: TRIAGE_SIZES[Math.max(0, Math.min(TRIAGE_SIZES.length - 1, size.level))]!, confidence: size.confidence };
+  const solo = yesOf(result?.answers, "solo");
+  return { size: TRIAGE_SIZES[Math.max(0, Math.min(TRIAGE_SIZES.length - 1, size.level))]!, confidence: size.confidence, ...(solo !== undefined ? { solo } : {}) };
 }
 
 const HINT = 0.5;
@@ -155,7 +172,7 @@ export function suggestedPath(triage: TaskTriage): string {
   if (triage.ambiguous >= HINT) return "clarify first: the request as written probably misses a decision.";
   const smallish = (triage.size === "trivial" || triage.size === "small") && triage.sizeConfidence >= 0.6;
   const steps: string[] = [];
-  if (smallish && touched.length === 1) steps.push(`single-domain shortcut (${touched[0]}): skip the scout round and the proposal ceremony, state the short plan and delegate`);
+  if (smallish && touched.length === 1) steps.push(`fast track (${touched[0]}): no scouts, proposal or plan; delegate straight away`);
   else if (touched.length > 0) steps.push(`scout only ${touched.join(", ")}`);
   if (triage.research >= HINT) steps.push("summon the researcher for the outside facts");
   return steps.length > 0 ? `${steps.join("; ")}.` : "no strong signal; decide from the request.";

package/src/execution/agent-runner.ts

@@ -4,7 +4,11 @@ import { roleSpec } from "../roles/registry.ts";
 import { compilePrompt } from "../prompts/compiler.ts";
 import { activityDetail, activityWord, describeToolCall } from "../pi/activity.ts";
 import { shortDuration, truncate } from "../text.ts";
-import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "./pi-runner.ts";
+import { EditLog } from "../state/changes.ts";
+import { formatMinutes, REPORT_GRACE_MS } from "../state/budget.ts";
+import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner, type RelayAsk } from "./pi-runner.ts";
+import { ASK_ENV } from "../ask/relay.ts";
+import { ASK_TOOL } from "../ask/types.ts";
 
 export interface AgentContext {
   task: string;
@@ -58,8 +62,49 @@ export interface AgentRequest {
   /** The classifier routed this run down from this configured profile (receipts and metrics show it). */
   routedFrom?: string;
   route?: string;
+  /** Under a task time budget: the run's allotted time, which replaces `timeoutMs`. */
+  time?: AgentTime;
+  /** Lets the agent ask the user (ask_user_question, relayed through the master); its clocks wait for the answers. */
+  onAsk?: RelayAsk;
 }
 
+/**
+ * A run under a task time budget. The agent is told its minutes up front,
+ * warned at 75%, and asked to stop and report when they run out. A worker
+ * then reports where it left off and how much more it needs; `onTimeUp`
+ * (the engine asking the user) grants more, and the same agent carries on.
+ */
+export interface AgentTime {
+  /** When the delegation's time runs out (epoch ms); moved out when more is granted, shared by retries and re-runs. */
+  endsAt: number;
+  /** The allotment, as the agent and the lobby see it. */
+  allotMs: number;
+  /** What the agent is told about its time, in its context. */
+  note?: string;
+  /** Workers only: decide on more time once it has reported where it left off; resolve with ms, 0 to stop it. */
+  onTimeUp?: (run: AgentRun, report: string) => Promise<number>;
+}
+
+/** The warning at 75% of an allotment. */
+export function headsUpMessage(leftMs: number, allotMs: number): string {
+  return `bot-lobby: about ${formatMinutes(leftMs)} of your ${formatMinutes(allotMs)} for this step are left. Finish what you have started and make sure it works; leave nice-to-haves.`;
+}
+
+/** The steer when an allotment is spent: a worker says where it left off and what more it needs; any other role reports what it has. */
+export function timeUpMessage(allotMs: number, canAskForMore: boolean): string {
+  return canAskForMore
+    ? `bot-lobby: your ${formatMinutes(allotMs)} for this step are up. Stop here: finish or revert the edit in progress so every file is consistent, start nothing new, and write your report now in the required format, adding \`## Left Off\` (what you were doing and what is still to do) and \`## More Time\` (how many more minutes you need, and why). The user decides whether you get more time to finish.`
+    : `bot-lobby: your ${formatMinutes(allotMs)} are up. Stop now and write your report in the required format with what you have.`;
+}
+
+/** The follow-up that sends an agent on once the user gave it more time. */
+export function carryOnMessage(extraMs: number): string {
+  return `bot-lobby: the user gave you ${formatMinutes(extraMs)} more. Carry on from where you left off and finish the step, then write your final report in the required format (leave out Left Off and More Time if you finish).`;
+}
+
+/** Least time an attempt starts with; a retry with less than this left is not started. */
+const MIN_ATTEMPT_MS = 60_000;
+
 /** The watchdog fields of an AgentRequest, taken from the workflow config. */
 export function watchdogOptions(workflow: {
   maxAgentRetries: number;
@@ -91,13 +136,18 @@ function retryable(run: AgentRun): boolean {
 export async function runAgent(request: AgentRequest, run: ProcessRunner = spawnPiProcess): Promise<AgentRun> {
   const startedAt = new Date().toISOString();
   const attempts = Math.max(1, (request.retries ?? 0) + 1);
+  // A failed attempt may have edited files before the retry: the run owns every edit.
+  const edits = new EditLog(request.cwd);
   let last: AgentRun | undefined;
   for (let attempt = 1; attempt <= attempts; attempt++) {
-    last = await runAgentOnce(request, run, attempt, startedAt);
+    last = await runAgentOnce(request, run, attempt, startedAt, edits);
     request.onAttemptEnd?.(last);
     if (!retryable(last)) break;
+    // Under a budget a retry only uses what is left of the allotment.
+    if (request.time && request.time.endsAt - Date.now() < MIN_ATTEMPT_MS) break;
   }
-  return last!;
+  const edited = edits.list();
+  return edited.length > 0 ? { ...last!, edited } : last!;
 }
 
 /** Abort every in-flight subagent (session shutdown, user cancel). */
@@ -120,31 +170,36 @@ function baseRun(request: AgentRequest, runId: string, startedAt: string, attemp
     ...(request.thinking ? { thinking: request.thinking } : {}),
     ...(request.routedFrom ? { routedFrom: request.routedFrom } : {}),
     ...(request.route ? { route: request.route } : {}),
+    ...(request.time ? { allotMs: request.time.allotMs, endsAt: request.time.endsAt } : {}),
     ...(attempts > 1 ? { note: `retry ${attempts - 1} of ${(request.retries ?? 0)}`, noteKind: "warning" as const } : {}),
   };
 }
 
 function toolsFor(request: AgentRequest): readonly string[] | undefined {
   const tools = roleSpec(request.role).tools;
-  if (!request.extraTools?.length) return tools;
-  return [...(tools ?? []), ...request.extraTools];
+  const extra = [...(request.extraTools ?? []), ...(request.onAsk ? [ASK_TOOL] : [])];
+  if (extra.length === 0) return tools;
+  return [...(tools ?? []), ...extra];
 }
 
 /**
  * Run one domain/role agent in an isolated pi process. The role's tool
  * allowlist comes from its spec, so read-only roles cannot modify anything.
  */
-async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt: number, startedAt: string): Promise<AgentRun> {
+async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt: number, startedAt: string, edits: EditLog): Promise<AgentRun> {
   const base = baseRun(request, `${request.taskId}:${request.domain}:${request.role}:${Date.now().toString(36)}`, startedAt, attempt);
   request.onUpdate?.(base);
-  const live = createLiveRun(base, request);
+  const live = createLiveRun(base, request, edits);
 
   const controller = new AbortController();
   activeControllers.add(controller);
   const signal = request.signal ? AbortSignal.any([request.signal, controller.signal]) : controller.signal;
   try {
     const systemPrompt = compilePrompt({ domain: request.domain, role: request.role, ...request.context });
-    const wrapUp = request.wrapUpAt && request.wrapUpAt > 0 && request.wrapUpAt < 1 ? Math.floor(request.timeoutMs * request.wrapUpAt) : 0;
+    const time = request.time;
+    const left = time ? Math.max(MIN_ATTEMPT_MS, time.endsAt - Date.now()) : 0;
+    const wrapUp = time ? 0 : request.wrapUpAt && request.wrapUpAt > 0 && request.wrapUpAt < 1 ? Math.floor(request.timeoutMs * request.wrapUpAt) : 0;
+    const onTimeUp = time?.onTimeUp;
     const result = await runPiAgent({
       cwd: request.cwd,
       task: request.instruction,
@@ -152,9 +207,29 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
       tools: toolsFor(request),
       model: request.model,
       thinking: request.thinking,
-      timeoutMs: request.timeoutMs,
+      timeoutMs: time ? left + REPORT_GRACE_MS : request.timeoutMs,
+      ...(time ? {
+        time: {
+          upAtMs: left,
+          headsUpAtMs: left >= 4 * 60_000 ? Math.floor(left * 0.75) : 0,
+          headsUpMessage: headsUpMessage(left - Math.floor(left * 0.75), time.allotMs),
+          upMessage: timeUpMessage(time.allotMs, Boolean(onTimeUp)),
+          graceMs: REPORT_GRACE_MS,
+          ...(onTimeUp ? {
+            onTimeUp: async (report: string) => {
+              const extraMs = await onTimeUp(live.current(), report);
+              if (extraMs > 0) {
+                time.endsAt = Date.now() + extraMs;
+                live.annotate({ note: `given ${formatMinutes(extraMs)} more`, noteKind: "info" });
+              }
+              return { extraMs, message: carryOnMessage(extraMs) };
+            },
+          } : {}),
+        },
+      } : {}),
       signal,
-      env: request.env,
+      ...(request.onAsk ? { onAsk: request.onAsk } : {}),
+      env: request.onAsk ? { ...request.env, [ASK_ENV]: "1" } : request.env,
       stallTimeoutMs: request.stallTimeoutMs,
       toolStallTimeoutMs: request.toolStallTimeoutMs,
       wrapUpAtMs: wrapUp,
@@ -174,6 +249,8 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
       model: result.model ?? current.model,
       ...(result.stalled ? { stalled: true } : {}),
       ...(result.wrappedUp ? { wrappedUp: true } : {}),
+      ...(result.timeUp ? { timeUp: true } : {}),
+      ...(result.extendedMs ? { extendedMs: result.extendedMs } : {}),
       note: undefined,
       noteKind: undefined,
     };
@@ -198,7 +275,7 @@ const THROTTLE_MS = 2000;
  * `onUpdate`: activity changes, retries and notes immediately, counters and
  * heartbeats at most every couple of seconds.
  */
-function createLiveRun(base: AgentRun, request: AgentRequest) {
+function createLiveRun(base: AgentRun, request: AgentRequest, edits: EditLog) {
   let state: AgentRun = base;
   let lastEmit = 0;
   const emit = (patch: Partial<AgentRun>, force: boolean) => {
@@ -212,6 +289,7 @@ function createLiveRun(base: AgentRun, request: AgentRequest) {
   const onEvent = (event: PiStreamEvent) => {
     switch (event.type) {
       case "tool_execution_start": {
+        edits.note(event.toolName, event.args);
         const activity = activityWord(event.toolName);
         const detail = activityDetail(event.toolName, event.args);
         const step = describeToolCall(event.toolName, event.args);
@@ -240,6 +318,20 @@ function createLiveRun(base: AgentRun, request: AgentRequest) {
       case "wrap_up":
         emit({ note: `asked to wrap up (${shortDuration(request.timeoutMs)} limit)`, noteKind: "warning", wrappedUp: true }, true);
         return;
+      case "time_up":
+        emit({ note: request.time?.onTimeUp ? "out of time: reporting where it left off" : "out of time: reporting", noteKind: "warning" }, true);
+        return;
+      case "extended":
+        emit({ endsAt: request.time?.endsAt, extendedMs: (state.extendedMs ?? 0) + event.ms }, true);
+        return;
+      case "asking":
+        emit({ note: `waiting on you: ${event.questions} question${event.questions === 1 ? "" : "s"}`, noteKind: "info" }, true);
+        return;
+      case "answered":
+        // Its time waited with it.
+        if (request.time) request.time.endsAt += event.waitedMs;
+        emit({ note: "you answered; carrying on", noteKind: "info", ...(request.time ? { endsAt: request.time.endsAt } : {}) }, true);
+        return;
       case "usage": {
         const usage = state.usage ?? { input: 0, output: 0, cost: 0, turns: 0 };
         const next = { input: usage.input + event.input, output: usage.output + event.output, cost: usage.cost + event.cost, turns: usage.turns + 1 };

package/src/execution/git.ts

@@ -1,4 +1,6 @@
 import { execFile } from "node:child_process";
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
 import { promisify } from "node:util";
 import { truncate } from "../text.ts";
 
@@ -10,33 +12,128 @@ async function git(cwd: string, args: string[]): Promise<string> {
   return stdout.trim();
 }
 
-/** `git diff HEAD`, falling back to index+worktree when HEAD does not exist yet. */
-async function diffAgainstHead(cwd: string): Promise<string> {
+/** `git diff <base>` (HEAD by default), falling back to index+worktree when HEAD does not exist yet. */
+async function diffAgainst(cwd: string, base: string, extra: readonly string[] = [], paths: readonly string[] = []): Promise<string> {
   try {
-    return await git(cwd, ["diff", "HEAD"]);
+    return await git(cwd, ["diff", ...extra, base, "--", ...paths]);
   } catch {
-    const [unstaged, staged] = await Promise.all([git(cwd, ["diff"]), git(cwd, ["diff", "--cached"])]);
+    const [unstaged, staged] = await Promise.all([git(cwd, ["diff", ...extra, "--", ...paths]), git(cwd, ["diff", ...extra, "--cached", "--", ...paths])]);
     return [unstaged, staged].filter((part) => part.length > 0).join("\n");
   }
 }
 
+/** The commit HEAD points at, or undefined (no commits yet, or no git). */
+export async function headCommit(cwd: string): Promise<string | undefined> {
+  try {
+    return (await git(cwd, ["rev-parse", "--verify", "HEAD"])) || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** The newest commit on HEAD made before `iso` (where a task started), or undefined. */
+export async function commitBefore(cwd: string, iso: string): Promise<string | undefined> {
+  try {
+    return (await git(cwd, ["rev-list", "-1", `--before=${iso}`, "HEAD"])) || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export interface DiffOptions {
+  /** Bound on the whole text. */
+  limitChars?: number;
+  /** The commit to compare with (where the task started), so work already committed still shows; HEAD when absent. */
+  base?: string;
+  /** Paths (relative to `cwd`) left out: bot-lobby's own records. */
+  exclude?: readonly string[];
+}
+
+/** Longest new file shown whole; past it (or binary) only its name is listed. */
+const MAX_NEW_FILE_CHARS = 4000;
+const MAX_NEW_FILE_BYTES = 200 * 1024;
+
 /**
- * Repository evidence for a reviewer: working-tree status plus the diff against
- * HEAD. Returns an explanatory string instead of throwing when git is unusable
- * so a review can still proceed on other evidence.
+ * Repository evidence for a reviewer: working-tree status, the files changed
+ * since `base` (listed first, so a long diff never hides which files moved),
+ * the diff itself, and the content of new files (which `git diff` leaves
+ * out). Returns an explanatory string instead of throwing when git is
+ * unusable so a review can still proceed on other evidence.
  */
-export async function readRepositoryDiff(cwd: string, limitChars = 20_000): Promise<string> {
+export async function readRepositoryDiff(cwd: string, options: DiffOptions = {}): Promise<string> {
+  const limit = options.limitChars ?? 20_000;
+  const paths = options.exclude?.length ? [".", ...options.exclude.map((path) => `:(exclude)${path}`)] : [];
+  const base = options.base ?? "HEAD";
+  const label = options.base ? `since ${options.base.slice(0, 7)}, where the task started (committed work included)` : "HEAD";
   try {
-    const [status, diff] = await Promise.all([
-      git(cwd, ["status", "--porcelain"]),
-      diffAgainstHead(cwd),
+    const [status, stat, diff, untracked] = await Promise.all([
+      git(cwd, ["status", "--porcelain", "--", ...paths]),
+      diffAgainst(cwd, base, ["--stat"], paths),
+      diffAgainst(cwd, base, [], paths),
+      git(cwd, ["ls-files", "--others", "--exclude-standard", "--", ...paths]),
     ]);
-    const parts = [
+    const head = [
       status ? `Status:\n${status}` : "Status: clean working tree",
-      diff ? `Diff (HEAD):\n${diff}` : "Diff (HEAD): none",
+      stat ? `Changed files (${label}):\n${stat}` : "",
+    ].filter(Boolean).join("\n\n");
+    const fresh = untracked ? newFiles(cwd, untracked.split("\n").filter(Boolean)) : "";
+    const room = Math.max(0, limit - head.length);
+    // The diff and the new files share what is left; new files get at least a third when there are any.
+    const diffRoom = fresh ? Math.max(Math.floor(room * 0.66), room - fresh.length) : room;
+    const parts = [
+      head,
+      diff ? `Diff (${label}):\n${truncate(diff, diffRoom)}` : `Diff (${label}): none`,
+      fresh ? `New files (untracked):\n${truncate(fresh, Math.max(0, room - Math.min(diff.length, diffRoom)))}` : "",
     ];
-    return truncate(parts.join("\n\n"), limitChars);
+    return truncate(parts.filter(Boolean).join("\n\n"), limit + 200);
   } catch (error) {
     return `Unable to read git state: ${(error as Error).message}`;
   }
 }
+
+/** New files as a reviewer reads them: each whole when it is small text, otherwise just named. */
+function newFiles(cwd: string, files: readonly string[]): string {
+  return files.map((file) => {
+    try {
+      const path = join(cwd, file);
+      if (statSync(path).size > MAX_NEW_FILE_BYTES) return `--- ${file} (large; read it directly)`;
+      const text = readFileSync(path, "utf8");
+      if (text.includes("\0")) return `--- ${file} (binary)`;
+      return `--- ${file}\n${truncate(text, MAX_NEW_FILE_CHARS)}`;
+    } catch {
+      return `--- ${file} (unreadable)`;
+    }
+  }).join("\n\n");
+}
+
+/** Most changed files one look reports; the rest are summarised by the diff. */
+export const MAX_CHANGED_FILES = 400;
+
+/**
+ * The repository's top folder and every file changed, relative to it: what
+ * `git status` reports (renames by their new path, untracked files one by
+ * one), plus what was committed since `base`; undefined when git is unusable.
+ */
+export async function changedFiles(cwd: string, base?: string): Promise<{ top: string; files: string[] } | undefined> {
+  try {
+    const [top, status, committed] = await Promise.all([
+      git(cwd, ["rev-parse", "--show-toplevel"]),
+      run("git", ["status", "--porcelain", "-z", "--untracked-files=all"], { cwd, maxBuffer: MAX_BUFFER }),
+      // Work committed since the task started is still the task's to review.
+      base ? run("git", ["diff", "--name-only", "-z", base], { cwd, maxBuffer: MAX_BUFFER }).then((result) => result.stdout, () => "") : Promise.resolve(""),
+    ]);
+    const entries = status.stdout.split("\0");
+    const files = new Set<string>();
+    for (let index = 0; index < entries.length && files.size < MAX_CHANGED_FILES; index += 1) {
+      const entry = entries[index]!;
+      if (entry.length < 4) continue;
+      files.add(entry.slice(3));
+      // A rename or copy is followed by the path it came from.
+      if (/[RC]/.test(entry.slice(0, 2))) index += 1;
+    }
+    for (const file of committed.split("\0")) if (file && files.size < MAX_CHANGED_FILES) files.add(file);
+    return { top, files: [...files] };
+  } catch {
+    return undefined;
+  }
+}