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

package/src/lobby/service.ts

@@ -5,10 +5,18 @@
  */
 import { SessionManager, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
-import { loadTask, peekTasks } from "../state/persistence.ts";
+import { updateBlockingRequest } from "../state/blocking-requests.ts";
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadTask, ownedTask, peekTasks, saveTask } from "../state/persistence.ts";
+import { refreshReview, deferReview } from "../delivery/review.ts";
+import { deliver, type DeliveryRequest, type DeliveryStore } from "../delivery/operations.ts";
+import type { LockIdentity } from "../delivery/lock.ts";
+import { execCommand } from "./issues.ts";
 import { releaseAttachments } from "../state/attachments.ts";
 import { loadConfig, saveConfig as writeConfig } from "../state/project.ts";
-import { addPlanComment, readPlanComments } from "../state/comments.ts";
+import { addPlanComment, editComment, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
 import { livePresence } from "../state/presence.ts";
@@ -40,6 +48,34 @@ import type { LiveSession, LobbyService, SwitchTarget } from "./host.ts";
 import { pushNotice, type NoticeLevel } from "../webui/notices.ts";
 import type { Runtime } from "./runtime.ts";
 
+function deliveryTask(state: Runtime, taskId: string): Task {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(taskId) || taskId === "." || taskId === "..") throw new Error("Invalid task ID.");
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task || task.state !== "completed" || !task.delivery) throw new Error("Completed task delivery review is unavailable in this project.");
+  return task;
+}
+
+function recoveryDeliveryStore(state: Runtime, identity: LockIdentity): DeliveryStore {
+  if (identity.configDir !== resolve(state.configDir) || realpathSync(identity.projectRoot) !== identity.projectRoot) throw new Error("Interrupted owner has an untrusted project/config identity.");
+  return deliveryStore({ ...state, root: identity.projectRoot }, identity.taskId);
+}
+function deliveryStore(state: Runtime, taskId: string): DeliveryStore {
+  let baseline: string | undefined;
+  return {
+    identity: { projectRoot: realpathSync(state.root), configDir: resolve(state.configDir) },
+    recoveryStore: (identity) => recoveryDeliveryStore(state, identity),
+    load: () => { const task = deliveryTask(state, taskId); baseline = JSON.stringify(task.delivery); return task; },
+    save: (task) => {
+      const latest = deliveryTask(state, taskId);
+      if (JSON.stringify(latest.delivery) !== baseline) throw new Error("Delivery changed during operation; reconcile before retrying.");
+      latest.delivery = structuredClone(task.delivery);
+      saveTask(state.root, state.configDir, latest);
+      baseline = JSON.stringify(latest.delivery);
+      lobbyTopics.bump("tasks");
+    },
+  };
+}
+
 /** The state background callbacks report to; set while the lobby service runs. */
 let serviceState: Runtime | undefined;
 
@@ -82,6 +118,12 @@ function addComment(state: Runtime, taskId: string, text: string): string {
   }
   lobbyFeed.log("LOBBY", `comment on ${taskId}'s plan saved`, "info");
   lobbyTopics.bump("plans");
+  lobbyTopics.bump("tasks");
+  return deliverComment(task, sessionId);
+}
+
+function deliverComment(task: Task, sessionId: string): string {
+  const taskId = task.id;
   if (task.ownerSessionId === sessionId) {
     if (deliverComments() === 0) return `comment saved — it reaches the oracle once ${taskId} is resumed or restored`;
     return `comment sent to the oracle — it will ${task.plan ? "amend the plan" : "revise the proposal"}`;
@@ -90,6 +132,26 @@ function addComment(state: Runtime, taskId: string, text: string): string {
   return `comment saved — the session driving ${taskId} passes it to its oracle`;
 }
 
+/**
+ * Correct a comment this session sent. Ownership is checked again here, not
+ * only at the API boundary: the session that wrote the comment is the only one
+ * that may change its words.
+ */
+function editOwnComment(state: Runtime, taskId: string, commentId: string, text: string): PlanComment {
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task) throw new Error(`no task ${taskId}`);
+  const sessionId = state.ctx.sessionManager.getSessionId();
+  const comment = readPlanComments(state.root, state.configDir, taskId).find((entry) => entry.id === commentId);
+  if (!comment) throw new Error(`no comment ${commentId} on ${taskId}`);
+  if (!comment.by || comment.by !== sessionId) throw new Error(`only the session that wrote ${commentId} can edit it`);
+  const edited = editComment(state.root, state.configDir, taskId, commentId, text);
+  lobbyFeed.log("LOBBY", `comment ${commentId} on ${taskId}'s plan edited`, "info");
+  lobbyTopics.bump("plans");
+  lobbyTopics.bump("tasks");
+  deliverComment(task, sessionId);
+  return edited;
+}
+
 function failed(state: Runtime, what: string, error: Error): void {
   lobbyFeed.log("LOBBY", `${what} — ${error.message}`, "error");
   lobbyNotify(state, `bot-lobby: ${what} — ${error.message}`, "error");
@@ -184,6 +246,20 @@ function sessionsChanged(): void {
   }
 }
 
+function dialogTracker(state: Runtime): (id: string, pending: boolean, sessionId?: string) => void {
+  const requests = new Map<string, { taskId: string; sessionId: string; requestId: string }>();
+  const prefix = `dialog:${randomUUID()}`;
+  return (id, pending, sessionId) => {
+    if (!sessionId) return;
+    const task = pending ? ownedTask(state.root, state.configDir, sessionId) : undefined;
+    if (task && !requests.has(id)) requests.set(id, { taskId: task.id, sessionId, requestId: `${prefix}:${id}` });
+    const request = requests.get(id);
+    if (!request) return;
+    updateBlockingRequest({ root: state.root, configDir: state.configDir, ...request }, request.requestId, pending);
+    if (!pending) requests.delete(id);
+  };
+}
+
 /** Start a task in its own new pi session, named after the task; the session, or why not. */
 function startSession(state: Runtime, start: { request?: string; plan?: PlannedTask; auto?: boolean }): BackgroundSession | string {
   const request = start.request?.trim();
@@ -198,7 +274,7 @@ function startSession(state: Runtime, start: { request?: string; plan?: PlannedT
   // A request may lead with flags (`--worktree add login`); the session is named after what follows them.
   const name = taskName(plan?.title ?? (stripStartFlags(request!) || request!));
   try {
-    const session = sessionRegistry().start(state.ctx.cwd, { name, ...(plan ? { planId: plan.id } : { request: request! }), ...(start.auto ? { auto: true } : {}) }, sessionModel(state.ctx));
+    const session = sessionRegistry().start(state.ctx.cwd, { name, projectRoot: state.root, onDialog: dialogTracker(state), ...(plan ? { planId: plan.id } : { request: request! }), ...(start.auto ? { auto: true } : {}) }, sessionModel(state.ctx));
     lobbyFeed.log("LOBBY", `started "${name}" in a new session`, "success");
     return session;
   } catch (error) {
@@ -318,7 +394,7 @@ function archiveTask(state: Runtime, taskId: string): string {
   if (busy) return busy;
   try {
     archiveTaskOnDisk(state.root, state.configDir, taskId);
-    releaseAttachments(taskId);
+    releaseAttachments(taskId, state.root);
   } catch (error) {
     return (error as Error).message;
   }
@@ -347,7 +423,7 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
   }
   try {
     deleteTaskOnDisk(state.root, state.configDir, taskId, where);
-    releaseAttachments(taskId);
+    releaseAttachments(taskId, state.root);
   } catch (error) {
     return (error as Error).message;
   }
@@ -485,6 +561,7 @@ export function createLobbyService(state: Runtime): LobbyService {
   };
   let appliedMaster = masterKey();
   return {
+    projectRoot: () => state.root,
     sessionId: () => state.ctx.sessionManager.getSessionId(),
     zen: () => {
       const snapshot = taskSnapshot();
@@ -493,12 +570,33 @@ export function createLobbyService(state: Runtime): LobbyService {
     feed: lobbyFeed,
     masterBusy: () => !state.ctx.isIdle(),
     tasks: () => peekTasks(state.root, state.configDir),
+    deliveryDeliver: (taskId, request: DeliveryRequest) => deliver(request, { cwd: state.root, exec: execCommand }, deliveryStore(state, taskId)),
+    deliveryReview: async (taskId) => {
+      const task = deliveryTask(state, taskId);
+      const baseline = JSON.stringify(task.delivery);
+      const delivery = await refreshReview(task, { cwd: state.root, exec: execCommand });
+      // An async lookup must not overwrite intervening deferrals or operations.
+      const latest = deliveryTask(state, taskId);
+      if (JSON.stringify(latest.delivery) !== baseline) throw new Error("Review changed during lookup; refresh again.");
+      latest.delivery = delivery;
+      saveTask(state.root, state.configDir, latest);
+      lobbyTopics.bump("tasks");
+      return delivery;
+    },
+    deliveryDefer: (taskId, reviewId) => {
+      const task = deliveryTask(state, taskId);
+      const delivery = deferReview(task, reviewId);
+      saveTask(state.root, state.configDir, task);
+      lobbyTopics.bump("tasks");
+      return delivery;
+    },
     plans: () => listPlannedTasks(state.root, state.configDir),
     comments: (taskId) => readPlanComments(state.root, state.configDir, taskId),
     metrics: () => readMetrics(state.root, state.configDir),
     classifierMetrics: () => readClassifierMetrics(state.root, state.configDir),
     toOracle: (text) => toOracle(state, text),
     comment: (taskId, text) => addComment(state, taskId, text),
+    editComment: (taskId, commentId, text) => editOwnComment(state, taskId, commentId, text),
     startPlanned: (plan) => startPlanned(state, plan),
     discardPlan: (id) => {
       discardPlannedTask(state.root, state.configDir, id);
@@ -556,7 +654,7 @@ export function createLobbyService(state: Runtime): LobbyService {
     workspace: () => state.workspace,
     refreshWorkspace: () => refreshWorkspace(state),
     sessionName: () => state.pi.getSessionName(),
-    sessions: () => backgroundSessions(),
+    sessions: () => backgroundSessions().filter((session) => session.projectRoot === state.root),
     startSession: (start) => startSession(state, start),
     isAuto: (taskId) => autoFor(state, taskId),
     setAuto: (taskId, on) => switchAuto(state, taskId, on),

package/src/lobby/sessions.ts

@@ -39,6 +39,9 @@ export interface SessionProcess {
 export type SessionStatus = "starting" | "idle" | "working" | "exited";
 
 export interface SessionStart {
+  /** Server-owned task association; never supplied by a browser payload. */
+  onDialog?: (id: string, pending: boolean, sessionId?: string) => void;
+  projectRoot?: string;
   /** The display name: the task's title. */
   name: string;
   /** What to send once it is up: the request, or a planned task to start. */
@@ -54,6 +57,7 @@ export const STOP_GRACE_MS = 5000;
 
 export class BackgroundSession {
   readonly key: string;
+  readonly projectRoot?: string;
   readonly name: string;
   /** The planned task it was started from. */
   readonly planId?: string;
@@ -67,6 +71,7 @@ export class BackgroundSession {
   exitCode?: number | null;
   /** Dialogs the session waits on, oldest first. */
   readonly dialogs: SessionDialog[] = [];
+  private readonly onDialog: NonNullable<SessionStart["onDialog"]>;
   private readonly proc: SessionProcess;
   private buffer = "";
   private stderr = "";
@@ -79,7 +84,9 @@ export class BackgroundSession {
     counter += 1;
     this.key = `S${counter}`;
     this.name = start.name;
+    this.projectRoot = start.projectRoot;
     if (start.planId) this.planId = start.planId;
+    this.onDialog = start.onDialog ?? (() => {});
     this.proc = proc;
     this.onChange = onChange;
     proc.stdout?.on("data", (chunk) => this.receive(String(chunk)));
@@ -102,6 +109,7 @@ export class BackgroundSession {
     if (this.status === "exited") return;
     this.status = "exited";
     this.exitCode = code;
+    for (const dialog of this.dialogs) this.onDialog(dialog.id, false, this.sessionId);
     this.dialogs.length = 0;
     if (this.killTimer) clearTimeout(this.killTimer);
     this.feed.say("note", reason);
@@ -148,6 +156,7 @@ export class BackgroundSession {
 
   /** Stop the oracle's running turn (the session stays up). */
   abort(): void {
+    for (const dialog of [...this.dialogs]) this.answer(dialog.id, { cancelled: true });
     if (this.busy) this.write({ type: "abort" });
   }
 
@@ -156,6 +165,7 @@ export class BackgroundSession {
     const index = this.dialogs.findIndex((dialog) => dialog.id === id);
     if (index < 0) return;
     this.dialogs.splice(index, 1);
+    this.onDialog(id, false, this.sessionId);
     if (this.alive && this.proc.stdin) this.proc.stdin.write(`${JSON.stringify({ type: "extension_ui_response", id, ...answer })}\n`);
     this.onChange();
   }
@@ -213,6 +223,7 @@ export class BackgroundSession {
       if (event.command === "get_state" && data) {
         this.sessionId = data.sessionId;
         this.sessionFile = data.sessionFile;
+        for (const dialog of this.dialogs) this.onDialog(dialog.id, true, this.sessionId);
         if (this.status === "starting") this.status = "idle";
       } else if (event.success === false && typeof event.error === "string") {
         this.feed.log("LOBBY", `the session refused a request: ${event.error}`, "warning");
@@ -240,6 +251,7 @@ export class BackgroundSession {
         ...(typeof event.placeholder === "string" ? { placeholder: event.placeholder } : {}),
         ...(typeof event.prefill === "string" ? { prefill: event.prefill } : {}),
       });
+      this.onDialog(id, true, this.sessionId);
       this.feed.log("LOBBY", `waiting for you: ${String(event.title ?? "a question").split("\n")[0]}`, "warning");
     } else if (method === "notify") {
       const level = event.notifyType === "error" ? "error" : event.notifyType === "warning" ? "warning" : "info";

package/src/lobby/task-rows.ts

@@ -1,11 +1,16 @@
 /** The shapes of the Tasks tab's rows, shared by the web API and the page's words. */
 
+import type { TimingProjection } from "../state/phase-timing.ts";
+import type { Delivery } from "../delivery/types.ts";
+
 export type TaskSection = "mine" | "others" | "pending" | "recent" | "archived";
 
 /** How a row is ticked off: still to do (a plan, or a task under way), completed, or abandoned. */
 export type CheckState = "open" | "done" | "dropped";
 
 export interface TaskRow {
+  timing?: TimingProjection;
+  delivery?: Pick<Delivery, "status" | "reviewId">;
   /** A task on the list, a saved plan, or a task in the archive. */
   kind: "task" | "plan" | "archived";
   id: string;

package/src/master/master.ts

@@ -52,7 +52,7 @@ export interface ScoutRequest {
 /** Model, thinking and time limit for one run, from settings. */
 function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
   const profile = profileFor(config, resolver, domain, role);
-  return { model: profile.model, thinking: profile.thinking, timeoutMs: profile.timeoutMs, ...(profile.fallback ? { fallback: profile.fallback } : {}) };
+  return { model: profile.model, thinking: profile.thinking, timeoutMs: profile.timeoutMs };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {

package/src/master/research.ts

@@ -88,7 +88,6 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       model: profile.model,
       thinking: profile.thinking,
       timeoutMs: profile.timeoutMs,
-      ...(profile.fallback ? { fallback: profile.fallback } : {}),
       ...(request.time ? { time: request.time } : {}),
       cwd: request.cwd,
       signal: request.signal,

package/src/pi/events.ts

@@ -7,7 +7,6 @@ import { selectKnowledge } from "../knowledge/selector.ts";
 import { cancelAllRuns } from "../execution/agent-runner.ts";
 import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
-import { registerMasterFallback } from "./master-fallback.ts";
 import { applyStatus, clearStatus, isMinimized, setMinimized } from "./ui.ts";
 import { isSubagentProcess, webToolsFor } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
@@ -65,7 +64,6 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
  * section rather than replacing the whole prompt.
  */
 export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
-  registerMasterFallback(pi);
   // Web tools the oracle put away for the task in hand, given back when it ends.
   let hiddenWeb: string[] = [];
   pi.on("session_start", (_event, ctx) => {

package/src/pi/model-settings.ts

@@ -26,14 +26,11 @@ export interface EntryView {
   thinking?: string;
   instructions?: string;
   timeoutMs?: number;
-  /** The model this agent switches to when its own runs out of usage; unset = none. */
-  fallbackModel?: string;
-  fallbackThinking?: string;
 }
 
 export function entryView(config: BotLobbyConfig, kind: SettingsKind): EntryView {
   if (kind === "master") return config.master;
-  if (kind === "scout") return { model: config.scout.model, timeoutMs: config.scout.timeoutMs, ...(config.scout.fallbackModel ? { fallbackModel: config.scout.fallbackModel } : {}) };
+  if (kind === "scout") return { model: config.scout.model, timeoutMs: config.scout.timeoutMs };
   if (kind === "researcher") return config.researcher;
   if (kind === "quickfix") return config.quickFix;
   if (kind === "planner") return config.planner;
@@ -45,33 +42,17 @@ interface EntryPatch {
   thinking?: string;
   instructions?: string;
   timeoutMs?: number;
-  /** `inherit` clears the fallback (its thinking level with it). */
-  fallbackModel?: string;
-  fallbackThinking?: string;
-}
-
-/** A settings entry with the fallback patch applied: `inherit` removes the fallback model and its thinking. */
-function withFallbackPatch<T extends { fallbackModel?: string; fallbackThinking?: string }>(entry: T): T {
-  if (entry.fallbackModel !== INHERIT_MODEL) return entry;
-  const { fallbackModel: _model, fallbackThinking: _thinking, ...rest } = entry;
-  return rest as T;
 }
 
 /** Apply a patch to one entry in a config copy; scouts ignore thinking and instructions. */
 export function patchEntry(config: BotLobbyConfig, kind: SettingsKind, patch: EntryPatch): BotLobbyConfig {
   const next: BotLobbyConfig = { ...config, agents: { ...config.agents } };
-  if (kind === "master") next.master = withFallbackPatch({ ...config.master, ...patch } as AgentModelConfig);
-  else if (kind === "scout") {
-    const fallbackModel = patch.fallbackModel ?? config.scout.fallbackModel;
-    next.scout = withFallbackPatch({
-      model: patch.model ?? config.scout.model,
-      timeoutMs: patch.timeoutMs ?? config.scout.timeoutMs,
-      ...(fallbackModel ? { fallbackModel } : {}),
-    });
-  } else if (kind === "researcher") next.researcher = withFallbackPatch({ ...config.researcher, ...patch } as AgentModelConfig);
-  else if (kind === "quickfix") next.quickFix = withFallbackPatch({ ...config.quickFix, ...patch } as AgentModelConfig);
-  else if (kind === "planner") next.planner = withFallbackPatch({ ...config.planner, ...patch } as AgentModelConfig);
-  else next.agents[kind] = withFallbackPatch({ ...config.agents[kind], ...patch } as AgentModelConfig);
+  if (kind === "master") next.master = { ...config.master, ...patch } as AgentModelConfig;
+  else if (kind === "scout") next.scout = { model: patch.model ?? config.scout.model, timeoutMs: patch.timeoutMs ?? config.scout.timeoutMs };
+  else if (kind === "researcher") next.researcher = { ...config.researcher, ...patch } as AgentModelConfig;
+  else if (kind === "quickfix") next.quickFix = { ...config.quickFix, ...patch } as AgentModelConfig;
+  else if (kind === "planner") next.planner = { ...config.planner, ...patch } as AgentModelConfig;
+  else next.agents[kind] = { ...config.agents[kind], ...patch } as AgentModelConfig;
   return next;
 }
 

package/src/pi/model-support.ts

@@ -8,7 +8,6 @@ import {
   type PanelMember,
   THINKING_LEVELS,
   type BotLobbyConfig,
-  type FallbackProfile,
   type ProfileResolver,
   type SubagentKind,
   type ThinkingLevelName,
@@ -87,25 +86,11 @@ export function createProfileResolver(config: BotLobbyConfig, options: ResolverO
         options.warn?.(message);
       }
     }
-    return { ...profile, model, thinking: check.level, ...clampedFallback(profile.fallback, kindLabel(profile.kind as SubagentKind), options) };
+    return { ...profile, model, thinking: check.level };
   };
 }
 
-/** The fallback with its thinking level clamped to what the fallback model supports. */
-function clampedFallback(fallback: FallbackProfile | undefined, label: string, options: ResolverOptions): { fallback?: FallbackProfile } {
-  if (!fallback) return {};
-  const check = checkThinking(options.lookup(fallback.model), fallback.thinking);
-  if (check.warning) {
-    const message = `bot-lobby: ${label} fallback — ${check.warning}. Change it in /bot-lobby settings.`;
-    if (!warned.has(message)) {
-      warned.add(message);
-      options.warn?.(message);
-    }
-  }
-  return { fallback: { model: fallback.model, thinking: check.level } };
-}
-
-type RunProfile = { model?: string; thinking: string; timeoutMs: number; instructions?: string; fallback?: FallbackProfile };
+type RunProfile = { model?: string; thinking: string; timeoutMs: number; instructions?: string };
 
 /** Unset models run on the session's; thinking is clamped to the model, with a one-time warning. */
 function resolveRunProfile(profile: RunProfile, label: string, options: ResolverOptions): RunProfile {
@@ -118,7 +103,7 @@ function resolveRunProfile(profile: RunProfile, label: string, options: Resolver
       options.warn?.(message);
     }
   }
-  return { ...profile, model, thinking: check.level, ...clampedFallback(profile.fallback, label, options) };
+  return { ...profile, model, thinking: check.level };
 }
 
 /** A lobby agent's model, thinking and time limit. */
@@ -137,7 +122,7 @@ export function resolvePanelProfile(config: BotLobbyConfig, member: PanelMember,
  */
 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);
+  return resolveRunProfile({ model: profile.model, thinking: profile.thinking, timeoutMs: profile.timeoutMs, ...(profile.instructions ? { instructions: profile.instructions } : {}) }, kindLabel("qa"), options);
 }
 
 /** Every configured subagent whose thinking level its model does not support, for `/bot-lobby config`. */

package/src/schemas/configuration.ts

@@ -31,18 +31,12 @@ export interface AgentModelConfig {
   instructions?: string;
   /** Time limit per run; falls back to `workflow.agentTimeoutMs`. */
   timeoutMs?: number;
-  /** Model this agent switches to when its own model runs out of usage or is unavailable; unset or `inherit` = none. */
-  fallbackModel?: ModelRef;
-  /** Thinking level on the fallback model; unset uses this agent's own `thinking`. */
-  fallbackThinking?: string;
 }
 
 /** Scouts pick a model and a time limit only; their thinking is fixed at `SCOUT_THINKING`. */
 export interface ScoutConfig {
   model: ModelRef;
   timeoutMs: number;
-  /** Model scouts switch to when theirs runs out of usage or is unavailable (they think at `SCOUT_THINKING` on it too). */
-  fallbackModel?: ModelRef;
 }
 
 /** Subagent kinds with their own settings entry. */
@@ -301,22 +295,18 @@ function positive(value: unknown): number | undefined {
 
 /** Merge one agent's override over its default; legacy `inherit` or unknown thinking falls back to the default level. */
 function normalizeAgent(base: AgentModelConfig, override: Partial<AgentModelConfig> | undefined): AgentModelConfig {
-  const { fallbackModel: rawModel, fallbackThinking: rawThinking, ...merged } = { ...base, ...(override ?? {}) };
+  const merged = { ...base, ...(override ?? {}) };
   const thinking = isThinkingLevel(merged.thinking) ? merged.thinking : base.thinking;
   const timeoutMs = positive(merged.timeoutMs) ?? base.timeoutMs;
-  const fallbackModel = typeof rawModel === "string" && rawModel.trim() && rawModel !== INHERIT_MODEL ? rawModel.trim() : undefined;
-  const fallbackThinking = typeof rawThinking === "string" && isThinkingLevel(rawThinking) ? rawThinking : undefined;
-  return { ...merged, thinking, ...(timeoutMs ? { timeoutMs } : {}), ...(fallbackModel ? { fallbackModel, ...(fallbackThinking ? { fallbackThinking } : {}) } : {}) };
+  return { model: merged.model, thinking, ...(typeof merged.instructions === "string" ? { instructions: merged.instructions } : {}), ...(timeoutMs ? { timeoutMs } : {}) };
 }
 
 /** Scouts keep a model and a time limit; any thinking value in the file is dropped. */
 function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig {
   const base = DEFAULT_CONFIG.scout;
-  const fallback = override?.fallbackModel;
   return {
     model: typeof override?.model === "string" && override.model.trim() ? override.model : base.model,
     timeoutMs: positive(override?.timeoutMs) ?? base.timeoutMs,
-    ...(typeof fallback === "string" && fallback.trim() && fallback !== INHERIT_MODEL ? { fallbackModel: fallback.trim() } : {}),
   };
 }
 
@@ -441,22 +431,6 @@ export interface AgentProfile {
   thinking: string;
   timeoutMs: number;
   instructions?: string;
-  /** Where the run goes when its model runs out of usage or is unavailable; absent = it just fails. */
-  fallback?: FallbackProfile;
-}
-
-/** The fallback model and the thinking level to run it at. */
-export interface FallbackProfile {
-  model: string;
-  thinking: string;
-}
-
-/** The fallback of a settings entry: its model and thinking (the entry's own level when none is set). */
-export function fallbackOf(entry: { fallbackModel?: string; fallbackThinking?: string; thinking?: string }): FallbackProfile | undefined {
-  const model = modelOf(entry.fallbackModel ?? INHERIT_MODEL);
-  if (!model) return undefined;
-  const own = entry.thinking && isThinkingLevel(entry.thinking) ? entry.thinking : DEFAULT_THINKING;
-  return { model, thinking: entry.fallbackThinking && isThinkingLevel(entry.fallbackThinking) ? entry.fallbackThinking : own };
 }
 
 /** The settings entry a domain/role run draws from. */
@@ -481,12 +455,10 @@ export function agentProfile(config: BotLobbyConfig, domain: Domain, role: Role)
   const instructions = config.agents[domain].instructions;
   const fallback = config.workflow.agentTimeoutMs;
   if (kind === "scout") {
-    const scoutFallback = fallbackOf({ fallbackModel: config.scout.fallbackModel, thinking: SCOUT_THINKING });
-    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions, ...(scoutFallback ? { fallback: scoutFallback } : {}) };
+    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions };
   }
   const entry = kind === "researcher" ? config.researcher : config.agents[kind];
-  const entryFallback = fallbackOf(entry);
-  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions, ...(entryFallback ? { fallback: entryFallback } : {}) };
+  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions };
 }
 
 /** The settings entry of a lobby agent (quick fix or planner). */
@@ -495,21 +467,19 @@ export function lobbyAgentConfig(config: BotLobbyConfig, kind: LobbyAgentKind):
 }
 
 /** Profile for a lobby agent run, from settings alone; `model` is undefined while unset. */
-export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string; fallback?: FallbackProfile } {
+export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string } {
   const entry = lobbyAgentConfig(config, kind);
-  const fallback = fallbackOf(entry);
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions, ...(fallback ? { fallback } : {}) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions };
 }
 
 /**
  * A planning panel seat's profile: the domain's (or the researcher's) model,
  * thinking and custom instructions, bounded by the planner's per-turn limit.
  */
-export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string; fallback?: FallbackProfile } {
+export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string } {
   const entry = member === "researcher" ? config.researcher : config.agents[member];
   const timeoutMs = config.planner.timeoutMs ?? config.workflow.agentTimeoutMs;
-  const fallback = fallbackOf(entry);
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions, ...(fallback ? { fallback } : {}) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions };
 }
 
 /** Resolves the model, thinking and time limit one subagent run uses. */

package/src/schemas/findings.ts

@@ -139,8 +139,6 @@ export interface AgentRun {
   wrappedUp?: boolean;
   /** File this worker is queued for at the file desk. */
   waitingFor?: string;
-  /** The run switched to its fallback model because this one ran out of usage or was unavailable. */
-  fellBackFrom?: string;
   /** The classifier routed this run down: the configured profile it came from (`p/big · medium`). */
   routedFrom?: string;
   /** Why and where it was routed (`trivial 0.88: p/big · medium → p/cheap · low`). */

package/src/schemas/task.ts

@@ -1,4 +1,5 @@
 import type { Domain, Role } from "./agent.ts";
+import type { Delivery } from "../delivery/types.ts";
 
 export const TASK_STATES = [
   "created",
@@ -171,7 +172,18 @@ export interface TaskGit {
   path?: string;
 }
 
+export interface PhaseTiming {
+  phase: TaskState;
+  elapsedMs: number;
+  runningSince?: string;
+  blockingRequestIds: string[];
+}
+
 export interface Task {
+  /** Canonical waits, including legacy tasks without a reliable clock. */
+  blockingRequestIds?: string[];
+  phaseTiming?: PhaseTiming;
+  delivery?: Delivery;
   id: string;
   title: string;
   /** The user's original request, kept in full while `title` stays a short label. */
@@ -226,6 +238,8 @@ export function createTask(
     title,
     request,
     state: "created",
+    blockingRequestIds: [],
+    phaseTiming: { phase: "created", elapsedMs: 0, runningSince: now, blockingRequestIds: [] },
     domains: [],
     amendments: [],
     paused: false,