@a-t-h-i/bot-lobby 0.6.17 → 0.6.19

package/src/delivery/source.ts

@@ -0,0 +1,39 @@
+import { realpathSync } from "node:fs";
+import { resolve, isAbsolute } from "node:path";
+import type { Task } from "../schemas/task.ts";
+import { command, type DeliveryContext } from "./transport.ts";
+
+export interface Source { repository: string; remote: string; github: string; branch: string; commit: string; cwd: string }
+export function sha(value: string): string {
+  if (!/^[a-f0-9]{40}$/.test(value)) throw new Error("Missing or invalid commit identity; commit completed work and refresh review.");
+  return value;
+}
+function githubRemote(remote: string): string {
+  const match = /^(?:https:\/\/github\.com\/|git@github\.com:)([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?$/.exec(remote);
+  if (!match?.[1] || match[1].split("/").some((v) => v === "." || v === "..")) throw new Error("Origin must identify a GitHub repository without credentials; configure origin and refresh review.");
+  return match[1];
+}
+async function common(ctx: DeliveryContext): Promise<string> {
+  const dir = await command(ctx, "git", ["rev-parse", "--git-common-dir"]);
+  return realpathSync(resolve(ctx.cwd, dir));
+}
+export async function readSource(task: Task, ctx: DeliveryContext): Promise<Source> {
+  if (!task.git) throw new Error("Task has no Git isolation. Preserve the completed work and configure a task branch before delivery.");
+  const branch = task.git.branch;
+  if (!branch || branch === "main" || branch.startsWith("-") || /[\s\x00-\x1f]/.test(branch)) throw new Error("Invalid task branch; delivery cannot use main as its source.");
+  await command(ctx, "git", ["check-ref-format", "--branch", branch]);
+  const repository = await common(ctx);
+  const path = task.git.mode === "worktree" ? task.git.path : ctx.cwd;
+  if (!path || !isAbsolute(path)) throw new Error("Task working directory is missing; restore its isolated worktree.");
+  const sourceCtx = { ...ctx, cwd: realpathSync(path) };
+  if (await common(sourceCtx) !== repository) throw new Error("Task worktree belongs to a different repository; restore isolation.");
+  if (await command(sourceCtx, "git", ["symbolic-ref", "--short", "HEAD"]) !== branch) throw new Error("Task branch is not checked out in its working directory; restore it and refresh review.");
+  if (await command(sourceCtx, "git", ["status", "--porcelain"])) throw new Error("Task source has uncommitted changes. Commit only completed task work, then refresh review.");
+  const commit = sha(await command(sourceCtx, "git", ["rev-parse", `refs/heads/${branch}^{commit}`]));
+  const remote = await command(sourceCtx, "git", ["remote", "get-url", "origin"]);
+  return { repository, remote, github: githubRemote(remote), branch, commit, cwd: sourceCtx.cwd };
+}
+export async function refreshMain(ctx: DeliveryContext): Promise<string> {
+  await command(ctx, "git", ["fetch", "--no-tags", "origin", "+refs/heads/main:refs/remotes/origin/main"]);
+  return sha(await command(ctx, "git", ["rev-parse", "refs/remotes/origin/main^{commit}"]));
+}

package/src/delivery/transport.ts

@@ -0,0 +1,36 @@
+import type { Exec } from "../lobby/issues.ts";
+
+export interface DeliveryContext { exec: Exec; cwd: string }
+export async function command(ctx: DeliveryContext, tool: string, args: string[]): Promise<string> {
+  const result = await ctx.exec(tool, args, { cwd: ctx.cwd, timeout: 20_000 });
+  if (result.code !== 0) throw new Error(`${tool} lookup failed; check remote access and authentication, then refresh review.`);
+  return result.stdout.trim();
+}
+export async function api(ctx: DeliveryContext, endpoint: string): Promise<unknown> {
+  const text = await command(ctx, "gh", ["api", endpoint]);
+  try { return JSON.parse(text); }
+  catch { throw new Error("GitHub returned malformed JSON; refresh review after connectivity recovers."); }
+}
+export function object(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Malformed GitHub response; refresh review.");
+  return value as Record<string, unknown>;
+}
+export function strings(value: unknown): string[] {
+  if (!Array.isArray(value) || value.some((v) => typeof v !== "string" || !v.trim())) throw new Error("Malformed required check names.");
+  return value as string[];
+}
+export async function pages(ctx: DeliveryContext, endpoint: string, key?: string): Promise<unknown[]> {
+  const all: unknown[] = [];
+  for (let page = 1; page <= 100; page++) {
+    const raw = await api(ctx, `${endpoint}?per_page=100&page=${page}`);
+    const rows = key ? object(raw)[key] : raw;
+    if (!Array.isArray(rows) || rows.length > 100) throw new Error("Malformed GitHub pagination; refresh review.");
+    if (key && (!Number.isInteger(object(raw).total_count) || Number(object(raw).total_count) < all.length + rows.length)) throw new Error("Malformed check count.");
+    all.push(...rows);
+    if (rows.length < 100) {
+      if (key && object(raw).total_count !== all.length) throw new Error("Incomplete check pagination; refresh review.");
+      return all;
+    }
+  }
+  throw new Error("GitHub pagination exceeds safety limit; review checks manually.");
+}

package/src/delivery/types.ts

@@ -0,0 +1,60 @@
+/** Persisted delivery review contract; completion and publication are separate. */
+export type DeliveryStatus = "pending_approval" | "deferred" | "in_progress" | "successful" | "recoverable_failure";
+export type DeliveryAction = "create_pr" | "merge_main";
+export type DeliveryChecksState = "passing" | "failing" | "pending" | "absent" | "unavailable" | "stale";
+
+export interface DeliveryVerification {
+  checks: DeliveryChecksState;
+  summary: string;
+  localVerified: boolean;
+  requiredChecks: string[];
+  rulesKnown: boolean;
+}
+
+export interface DeliveryOperation {
+  id: string;
+  action: DeliveryAction;
+  sourceCommit: string;
+  repository?: string;
+  remote?: string;
+  sourceBranch?: string;
+  target?: "main";
+  fingerprint?: string;
+  reviewId?: string;
+  integrationPath?: string;
+  targetCommit?: string;
+  stage: string;
+  mergeCommit?: string;
+  pullNumber?: number;
+  pullUrl?: string;
+  startedAt: string;
+}
+
+export interface DeliveryResult {
+  action: DeliveryAction;
+  commit?: string;
+  pullNumber?: number;
+  pullUrl?: string;
+}
+
+export interface Delivery {
+  status: DeliveryStatus;
+  reviewId: string;
+  repository?: string;
+  remote?: string;
+  project: string;
+  sourceBranch: string;
+  sourceCommit?: string;
+  target: "main";
+  targetCommit?: string;
+  reviewedAt: string;
+  verification?: DeliveryVerification;
+  /** Fingerprint of reviewed rules and check responses; missing means not reviewed. */
+  fingerprint?: string;
+  blocked: Partial<Record<DeliveryAction, string>>;
+  operation?: DeliveryOperation;
+  /** Reconciled, non-delivered intents superseded only by explicit fresh approval. */
+  previousOperations?: DeliveryOperation[];
+  error?: string;
+  result?: DeliveryResult;
+}

package/src/execution/agent-runner.ts

@@ -7,7 +7,6 @@ import { shortDuration, truncate } from "../text.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 { isUnavailable, looksUnavailable, markUnavailable, usableFallback } from "./fallback.ts";
 import { ASK_ENV } from "../ask/relay.ts";
 import { ASK_TOOL } from "../ask/types.ts";
 import { agentOfRun, grantOption } from "../excalidraw/sessions.ts";
@@ -42,10 +41,6 @@ export interface AgentRequest {
   context: AgentContext;
   model?: string;
   thinking?: string;
-  /** Where the run goes when its model runs out of usage or is unavailable. */
-  fallback?: { model: string; thinking: string };
-  /** Set by the runner once it has switched: the model that ran out. */
-  fellBackFrom?: string;
   timeoutMs: number;
   cwd: string;
   signal?: AbortSignal;
@@ -141,24 +136,13 @@ function retryable(run: AgentRun): boolean {
  */
 export async function runAgent(request: AgentRequest, run: ProcessRunner = spawnPiProcess): Promise<AgentRun> {
   const startedAt = new Date().toISOString();
-  let attempts = Math.max(1, (request.retries ?? 0) + 1);
+  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;
-  // A model already known to be out of usage goes straight to the fallback.
-  const other = usableFallback(request.fallback, request.model);
-  if (other && isUnavailable(request.model)) request = switchToFallback(request, other, request.model ?? "the session model");
   for (let attempt = 1; attempt <= attempts; attempt++) {
     last = await runAgentOnce(request, run, attempt, startedAt, edits);
     request.onAttemptEnd?.(last);
-    // Out of usage (or the model unavailable): the same model would fail again, so the fallback takes the retry.
-    const fallback = usableFallback(request.fallback, request.model);
-    if (fallback && !request.fellBackFrom && last.status === "failed" && looksUnavailable(last.error)) {
-      if (request.model) markUnavailable(request.model);
-      request = switchToFallback(request, fallback, request.model ?? "the session model");
-      attempts += 1;
-      continue;
-    }
     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;
@@ -167,11 +151,6 @@ export async function runAgent(request: AgentRequest, run: ProcessRunner = spawn
   return edited.length > 0 ? { ...last!, edited } : last!;
 }
 
-/** The request moved to its fallback model and thinking level. */
-function switchToFallback(request: AgentRequest, fallback: { model: string; thinking?: string }, from: string): AgentRequest {
-  return { ...request, model: fallback.model, thinking: fallback.thinking ?? request.thinking, fellBackFrom: from };
-}
-
 /** Abort every in-flight subagent (session shutdown, user cancel). */
 export function cancelAllRuns(): void {
   for (const controller of activeControllers) controller.abort();
@@ -190,7 +169,6 @@ function baseRun(request: AgentRequest, runId: string, startedAt: string, attemp
     attempts,
     startedAt,
     ...(request.thinking ? { thinking: request.thinking } : {}),
-    ...(request.fellBackFrom ? { fellBackFrom: request.fellBackFrom } : {}),
     ...(request.routedFrom ? { routedFrom: request.routedFrom } : {}),
     ...(request.route ? { route: request.route } : {}),
     ...(request.time ? { allotMs: request.time.allotMs, endsAt: request.time.endsAt } : {}),

package/src/index.ts

@@ -5,6 +5,7 @@ import { registerOrchestrateTool } from "./pi/tools.ts";
 import { registerRouteTool } from "./pi/route.ts";
 import { onTransition } from "./state/task-state.ts";
 import { releaseAttachments } from "./state/attachments.ts";
+import { detectProjectRoot } from "./state/project.ts";
 import { TERMINAL_STATES } from "./schemas/task.ts";
 import { pingTransition } from "./pi/notify.ts";
 import { isSubagentProcess } from "./pi/quiet.ts";
@@ -19,6 +20,8 @@ import { registerWebTools } from "./web/tools.ts";
 import { registerExcalidrawTools } from "./excalidraw/tools.ts";
 
 export default function (pi: ExtensionAPI): void {
+  let root = detectProjectRoot(process.cwd(), CONFIG_DIR_NAME);
+  pi.on("session_start", (_event, ctx) => { root = detectProjectRoot(ctx.cwd, CONFIG_DIR_NAME); });
   // First, so every session_start handler below finds the classifier bound to this session's keys.
   registerClassifier(pi, CONFIG_DIR_NAME);
   // Before the lifecycle, so a task that ended while the oracle was idle is closed before it builds the next turn's prompt.
@@ -30,14 +33,14 @@ export default function (pi: ExtensionAPI): void {
   // A finished task takes the files attached during it along.
   onTransition((task) => {
     pingTransition(task);
-    if (TERMINAL_STATES.includes(task.state)) releaseAttachments(task.id);
+    if (TERMINAL_STATES.includes(task.state)) releaseAttachments(task.id, root);
   });
   registerCommands(pi, CONFIG_DIR_NAME);
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
   // A new request one agent can do alone: the oracle confirms, and the lobby hands it to the quick-fix agent.
   registerRouteTool(pi, CONFIG_DIR_NAME);
   // The questionnaire the oracle (and pi without a task) asks the user with; no other extension is needed for it.
-  registerAskTool(pi);
+  registerAskTool(pi, undefined, CONFIG_DIR_NAME);
   // The web tools, for the researcher and for pi without a task (the oracle leaves them to the researcher).
   registerWebTools(pi);
   // The shared Excalidraw sessions the user assigned to agents: the oracle here, every other agent through its own grant.

package/src/lobby/feed.ts

@@ -71,7 +71,6 @@ export class LobbyFeed {
   private readonly runThoughts = new Map<string, string>();
   private readonly runStatus = new Map<string, AgentRun["status"]>();
   /** Runs already reported as switched to their fallback model. */
-  private readonly fellBack = new Set<string>();
 
   onChange(listener: () => void): () => void {
     this.listeners.add(listener);
@@ -202,10 +201,6 @@ export class LobbyFeed {
       const before = this.runStatus.get(key);
       this.runStatus.set(key, run.status);
       if (before === undefined) this.log(source, `started as ${run.role}`, "info", at);
-      if (run.fellBackFrom && !this.fellBack.has(key)) {
-        this.fellBack.add(key);
-        this.log(source, `${run.fellBackFrom} is out of usage or unavailable: running on the fallback model`, "warning", at);
-      }
       if (run.step && this.runSteps.get(key) !== run.step) {
         this.runSteps.set(key, run.step);
         this.step(source, run.step, key, at);
@@ -231,7 +226,6 @@ export class LobbyFeed {
     this.runSteps.clear();
     this.runThoughts.clear();
     this.runStatus.clear();
-    this.fellBack.clear();
     this.touch();
   }
 }

package/src/lobby/host.ts

@@ -86,12 +86,16 @@ export interface ModelChoice {
 
 /** Everything the web server needs from pi and bot-lobby. */
 export interface LobbyService {
+  projectRoot?(): string;
   sessionId(): string | undefined;
   /** This session's active task and its runs, as the lobby reads them. */
   zen(): { task?: Task; runs: readonly AgentRun[] };
   feed: LobbyFeed;
   masterBusy(): boolean;
   tasks(): Task[];
+  deliveryDeliver?(taskId: string, request: import("../delivery/operations.ts").DeliveryRequest): Promise<import("../delivery/types.ts").Delivery>;
+  deliveryReview?(taskId: string): Promise<import("../delivery/types.ts").Delivery>;
+  deliveryDefer?(taskId: string, reviewId: string): import("../delivery/types.ts").Delivery;
   plans(): PlannedTask[];
   comments(taskId: string): PlanComment[];
   metrics(): MetricRecord[];
@@ -100,6 +104,8 @@ export interface LobbyService {
   /** Send text to the oracle, or start a task when none is active; returns a notice. */
   toOracle(text: string): string | undefined;
   comment(taskId: string, text: string): string;
+  /** Correct a comment this session sent; returns the edited comment. */
+  editComment(taskId: string, commentId: string, text: string): PlanComment;
   startPlanned(plan: PlannedTask): string;
   discardPlan(id: string): void;
   abortMaster(): void;

package/src/lobby/planner.ts

@@ -20,7 +20,6 @@
  */
 import { loadPrompt } from "../prompts/loader.ts";
 import { compilePrompt } from "../prompts/compiler.ts";
-import { withFallback } from "../execution/fallback.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { grantOption, type Grant } from "../excalidraw/sessions.ts";
 import { describeToolCall } from "../pi/activity.ts";
@@ -86,6 +85,7 @@ export interface PlannerMessage {
   role: "you" | "planner";
   text: string;
   at: number;
+  editedAt?: number;
   /** The round's questions, attributed, when the panel asked any. */
   questions?: PanelQuestion[];
   /** Questions the classifier answered with their recommended option instead of asking. */
@@ -574,6 +574,30 @@ export class PlanningSession {
     await this.post(text, settled);
   }
 
+  /** Correct an ordinary user turn, keeping the conversation and rerunning the panel. */
+  async editMessage(messageIndex: number, at: number, text: string): Promise<void> {
+    this.validateEdit(messageIndex, at, text);
+    this.messages = this.messages.map((message, index) => index === messageIndex ? { ...message, text: text.trim(), editedAt: Date.now() } : message);
+    this.reply = undefined;
+    this.questions = [];
+    this.answered = [];
+    this.lineComments = [];
+    this.notes = [];
+    this.memberNotes.clear();
+    this.lastStatus.clear();
+    this.autoContinued = false;
+    await this.turn();
+  }
+
+  /** Shared boundary checks, also used by HTTP before starting the background round. */
+  validateEdit(messageIndex: number, at: number, text: string): void {
+    if (this.busy) throw new Error("the panel is still thinking");
+    const message = this.messages[messageIndex];
+    if (!Number.isInteger(messageIndex) || messageIndex < 0 || !message || message.at !== at) throw new Error("the message has changed — refresh the conversation");
+    if (message.role !== "you" || message.settled?.length) throw new Error("only ordinary user messages can be edited");
+    if (!text.trim()) throw new Error("an edited message needs some text");
+  }
+
   private async post(text: string, settled?: readonly SettledQuestion[]): Promise<void> {
     const body = [text.trim(), commentBlock(this.lineComments)].filter(Boolean).join("\n\n");
     if (!body) return;
@@ -798,12 +822,7 @@ export class PlanningSession {
         },
         this.deps.runProcess ?? spawnPiProcess,
       );
-      // A model that is out of usage hands the turn to the fallback the settings name.
-      const { result, switchedFrom } = await withFallback(profile.model, profile.thinking, profile.fallback, attempt);
-      if (switchedFrom && profile.fallback) {
-        this.deps.feed?.log(label, `${switchedFrom} is out of usage or unavailable; ran on ${profile.fallback.model}`, "warning");
-        profile = { ...profile, model: profile.fallback.model, thinking: profile.fallback.thinking };
-      }
+      const result = await attempt(profile.model, profile.thinking);
       outcome = { status: result.status, output: result.output, ...(result.error ? { error: result.error } : {}), ...(result.model ? { model: result.model } : {}), usage: result.usage };
     } catch (error) {
       outcome = { status: "failed", output: "", error: (error as Error).message, usage: { input: 0, output: 0, cost: 0, turns: 0 } };

package/src/lobby/pr-review.ts

@@ -11,7 +11,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadPrompt } from "../prompts/loader.ts";
-import { withFallback } from "../execution/fallback.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { describeToolCall } from "../pi/activity.ts";
 import { appendMetrics } from "../state/metrics.ts";
@@ -284,12 +283,7 @@ export class PullReviews {
       },
       this.deps.runProcess ?? spawnPiProcess,
     );
-    const { result, switchedFrom } = await withFallback(profile.model, profile.thinking, profile.fallback, attempt);
-    if (switchedFrom && profile.fallback) {
-      review.model = profile.fallback.model;
-      review.thinking = profile.fallback.thinking;
-      this.step(review, `${switchedFrom} is out of usage or unavailable; ran on ${profile.fallback.model}`);
-    }
+    const result = await attempt(profile.model, profile.thinking);
     if (result.model) review.model = result.model;
     review.status = result.status === "success" ? "done" : result.status;
     const text = result.output.trim();

package/src/lobby/prompt-hub.ts

@@ -5,6 +5,7 @@
  * the answer, or with how it was put away. A cancelled caller's `signal`
  * withdraws the prompt.
  */
+import { blockingRequestContext } from "../state/blocking-requests.ts";
 import { lobbyTopics } from "./topics.ts";
 
 export type PromptKind = "questionnaire" | "choose" | "confirm" | "text" | "sessionDialog";
@@ -16,6 +17,9 @@ export interface WebPrompt {
   createdAt: number;
   from: string;
   payload: unknown;
+  taskId?: string;
+  sessionId?: string;
+  blockingRequestId?: string;
 }
 
 interface Pending {
@@ -50,7 +54,9 @@ export class PromptHub {
   /** Show a prompt on every surface; the answer settles it later. */
   open(kind: PromptKind, from: string, payload: unknown): WebPrompt {
     this.seq += 1;
-    const prompt: WebPrompt = { id: nextId(this.seq), kind, createdAt: Date.now(), from, payload };
+    const identity = blockingRequestContext.getStore();
+    const prompt: WebPrompt = { id: nextId(this.seq), kind, createdAt: Date.now(), from, payload,
+      ...(identity ? { taskId: identity.taskId, sessionId: identity.sessionId, blockingRequestId: identity.requestId } : {}) };
     this.pendingMap.set(prompt.id, { prompt });
     lobbyTopics.bump("prompts");
     return prompt;

package/src/lobby/pulls.ts

@@ -4,7 +4,7 @@
  * Like issues, `gh` owns authentication and repository detection; every
  * failure becomes one readable line.
  */
-import { gh, type Exec } from "./issues.ts";
+import { execCommand, gh, type Exec } from "./issues.ts";
 
 export type ChecksState = "passing" | "failing" | "pending";
 
@@ -193,6 +193,49 @@ export async function pullDiff(exec: Exec, cwd: string, number: number, limit =
   return stdout.length > limit ? `${stdout.slice(0, limit)}\n[…the diff continues: ${stdout.length - limit} more characters]` : stdout;
 }
 
+/** A pull request opened for a completed task's branch. */
+export interface CreatedPull {
+  number: number;
+  url: string;
+}
+
+const PUSH_TIMEOUT_MS = 60_000;
+
+async function run(exec: Exec, cwd: string, command: string, args: string[]): Promise<string> {
+  let result: Awaited<ReturnType<Exec>>;
+  try {
+    result = await exec(command, args, { cwd, timeout: PUSH_TIMEOUT_MS });
+  } catch (error) {
+    throw new Error(`${command} could not run — ${(error as Error).message}`);
+  }
+  if (result.code !== 0) throw new Error(result.stderr.trim() || `${command} exited with code ${result.code}`);
+  return result.stdout;
+}
+
+/** `gh pr create` ends with the URL on its own last line; the number is its tail. */
+function parseCreated(stdout: string): CreatedPull {
+  const url = stdout.trim().split("\n").map((line) => line.trim()).filter((line) => /^https?:\/\/\S+$/.test(line)).pop();
+  if (!url) throw new Error("gh pr create printed no pull request URL");
+  const match = /\/pull\/([1-9]\d*)$/.exec(url);
+  const number = Number(match?.[1]);
+  if (!Number.isSafeInteger(number) || number <= 0) throw new Error(`gh pr create printed an unreadable URL: ${url}`);
+  return { number, url };
+}
+
+/**
+ * Push a finished task's branch and open its pull request, so the work lands
+ * in review without the oracle having to remember a second step.
+ */
+export async function createPullRequest(options: { exec?: Exec; cwd: string; branch: string; base: string; title: string; body: string }): Promise<CreatedPull> {
+  for (const ref of [options.branch, options.base]) {
+    if (!ref || ref.startsWith("-") || /[\s~^:?*\[\\]|\.\.|@\{|\/\//.test(ref) || /[/.]$/.test(ref)) throw new Error("invalid pull request branch");
+  }
+  const exec = options.exec ?? execCommand;
+  await run(exec, options.cwd, "git", ["push", "-u", "origin", options.branch]);
+  const stdout = await gh(exec, options.cwd, ["pr", "create", "--base", options.base, "--head", options.branch, "--title", options.title, "--body", options.body.slice(0, 60_000)]);
+  return parseCreated(stdout);
+}
+
 /** Lobby state for the Git tab: the list, the open pull request, and what is loading. */
 export class PullsState {
   pulls: PullSummary[] = [];

package/src/lobby/quickfix.ts

@@ -6,7 +6,6 @@
  * and the lobby feed, and every finished job lands in the metrics log.
  */
 import { loadPrompt } from "../prompts/loader.ts";
-import { withFallback } from "../execution/fallback.ts";
 import { runPiAgent, spawnPiProcess, type PiStreamEvent, type ProcessRunner } from "../execution/pi-runner.ts";
 import { grantOption } from "../excalidraw/sessions.ts";
 import { describeToolCall } from "../pi/activity.ts";
@@ -77,7 +76,6 @@ export interface QuickFixProfile {
   timeoutMs: number;
   instructions?: string;
   /** Where the job goes when its model runs out of usage or is unavailable. */
-  fallback?: { model: string; thinking: string };
 }
 
 export interface QuickFixDeps {
@@ -265,17 +263,6 @@ export class QuickFixQueue {
         },
         this.deps.runProcess ?? spawnPiProcess,
       );
-      // A model that is out of usage hands the job to the fallback the settings name.
-      const attemptOrFallback = async (model: string | undefined, thinking: string) => {
-        const { result: outcome, switchedFrom } = await withFallback(model, thinking, profile.fallback, attempt);
-        if (switchedFrom && profile.fallback) {
-          job.model = profile.fallback.model;
-          job.thinking = profile.fallback.thinking;
-          this.addStep(job, `${switchedFrom} is out of usage or unavailable; ran on ${profile.fallback.model} (${profile.fallback.thinking})`, Date.now());
-          this.changed();
-        }
-        return outcome;
-      };
       let result;
       if (route) {
         job.route = routeLabel(route);
@@ -283,7 +270,7 @@ export class QuickFixQueue {
         job.thinking = route.thinking;
         if (route.model) job.model = route.model;
         this.changed();
-        result = await attemptOrFallback(route.model, route.thinking);
+        result = await attempt(route.model, route.thinking);
         if (fellShort(result) && !controller.signal.aborted) {
           // The routed attempt counts in the metrics on its own; the job re-runs on the configured profile.
           appendMetrics(this.deps.root, this.deps.configDir, [{ ...quickFixMetric({ ...job, status: result.status, finishedAt: Date.now(), usage: result.usage, ...(result.model ? { model: result.model } : {}) }), id: `${job.id}-routed-${job.startedAt}` }]);
@@ -292,10 +279,10 @@ export class QuickFixQueue {
           delete job.routedFrom;
           job.thinking = profile.thinking;
           if (profile.model) job.model = profile.model;
-          result = await attemptOrFallback(profile.model, profile.thinking);
+          result = await attempt(profile.model, profile.thinking);
         }
       } else {
-        result = await attemptOrFallback(profile.model, profile.thinking);
+        result = await attempt(profile.model, profile.thinking);
       }
       job.status = result.status;
       job.report = result.output.trim() || undefined;