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

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,

package/src/state/blocking-requests.ts

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { loadTask, saveTask } from "./persistence.ts";
+import { blockPhaseTiming, resolvePhaseTiming } from "./phase-timing.ts";
+
+export interface TaskRequestIdentity { root: string; configDir: string; taskId: string; sessionId?: string }
+export const blockingRequestContext = new AsyncLocalStorage<TaskRequestIdentity & { requestId: string }>();
+
+/** Always mutate a fresh authoritative task, never the workflow's long-lived copy. */
+export function updateBlockingRequest(identity: TaskRequestIdentity, id: string, pending: boolean): void {
+  const task = loadTask(identity.root, identity.configDir, identity.taskId);
+  if (!task || (identity.sessionId && task.ownerSessionId !== identity.sessionId)) return;
+  if (pending) blockPhaseTiming(task, id);
+  else resolvePhaseTiming(task, id);
+  saveTask(identity.root, identity.configDir, task);
+}
+
+export async function withBlockingRequest<T>(identity: TaskRequestIdentity, run: () => Promise<T>): Promise<T> {
+  const id = `request:${randomUUID()}`;
+  updateBlockingRequest(identity, id, true);
+  try { return await blockingRequestContext.run({ ...identity, requestId: id }, run); }
+  finally { updateBlockingRequest(identity, id, false); }
+}

package/src/state/persistence.ts

@@ -16,6 +16,13 @@ import {
 import { DEFAULT_KNOWLEDGE_CONTENT, ensureFile, readFileOr, writeFileEnsured } from "../knowledge/store.ts";
 import { forgetCached, forgetCachedUnder, readJsonCached } from "./file-cache.ts";
 import { taskName } from "../text.ts";
+import { mergePhaseTiming, timingBaseline, type TimingBaseline } from "./timing-merge.ts";
+
+const timingBaselines = new WeakMap<Task, TimingBaseline>();
+function rememberTiming(task: Task): Task {
+  timingBaselines.set(task, timingBaseline(task));
+  return task;
+}
 
 /** Idempotently create the full knowledge + tasks layout with seed files. */
 export function ensureProjectStructure(root: string, configDir: string): void {
@@ -40,6 +47,7 @@ export function createTaskDir(root: string, configDir: string, task: Task): void
   mkdirSync(dir, { recursive: true });
   forgetCached(join(dir, "state.json"));
   writeFileEnsured(join(dir, "state.json"), JSON.stringify(task, null, 2));
+  rememberTiming(task);
   ensureFile(join(dir, "proposal.md"), "");
   ensureFile(join(dir, "plan.md"), "");
   for (const domain of ["designer", "backend", "qa"] as const) {
@@ -80,9 +88,12 @@ export function readTaskArtifact(
 }
 
 export function saveTask(root: string, configDir: string, task: Task): void {
+  const latest = loadTask(root, configDir, task.id);
+  if (latest) mergePhaseTiming(task, timingBaselines.get(task), latest);
   const path = join(taskDir(dataRoot(root, configDir), task.id), "state.json");
   forgetCached(path);
   writeFileEnsured(path, JSON.stringify(task, null, 2));
+  rememberTiming(task);
 }
 
 /** Read a task state: the bot-lobby copy wins, else the newest pre-rename copy. */
@@ -91,7 +102,7 @@ export function loadTask(root: string, configDir: string, taskId: string): Task
     const path = join(taskDir(dr, taskId), "state.json");
     if (!existsSync(path)) continue;
     try {
-      return JSON.parse(readFileSync(path, "utf8")) as Task;
+      return rememberTiming(JSON.parse(readFileSync(path, "utf8")) as Task);
     } catch {
       // A bot-lobby state.json that exists but cannot be parsed is surfaced, not shadowed.
       return undefined;

package/src/state/phase-timing.ts

@@ -0,0 +1,53 @@
+import { TERMINAL_STATES, type Task, type TaskState } from "../schemas/task.ts";
+
+export interface TimingProjection {
+  phase: string;
+  elapsedMs: number;
+  runningSince?: string;
+  waiting: boolean;
+  serverNow: string;
+}
+
+function elapsed(task: Task, now: string): number {
+  const timing = task.phaseTiming;
+  if (!timing) return 0;
+  const delta = timing.runningSince ? Date.parse(now) - Date.parse(timing.runningSince) : 0;
+  return timing.elapsedMs + (Number.isFinite(delta) ? Math.max(0, delta) : 0);
+}
+
+export function resetPhaseTiming(task: Task, phase: TaskState, now: string): void {
+  const blockingRequestIds = [...(task.blockingRequestIds ?? task.phaseTiming?.blockingRequestIds ?? [])];
+  task.blockingRequestIds = [...blockingRequestIds];
+  task.phaseTiming = { phase, elapsedMs: 0, blockingRequestIds };
+  if (!blockingRequestIds.length && !TERMINAL_STATES.includes(phase)) task.phaseTiming.runningSince = now;
+}
+
+/** Legacy tasks remain unavailable until a real phase transition. */
+export function blockPhaseTiming(task: Task, id: string, now = new Date().toISOString()): void {
+  const ids = task.blockingRequestIds ?? task.phaseTiming?.blockingRequestIds ?? [];
+  if (ids.includes(id)) return;
+  task.blockingRequestIds = [...ids, id];
+  const timing = task.phaseTiming;
+  if (!timing) return;
+  timing.elapsedMs = elapsed(task, now);
+  delete timing.runningSince;
+  timing.blockingRequestIds = [...task.blockingRequestIds];
+}
+
+export function resolvePhaseTiming(task: Task, id: string, now = new Date().toISOString()): void {
+  const ids = task.blockingRequestIds ?? task.phaseTiming?.blockingRequestIds ?? [];
+  if (!ids.includes(id)) return;
+  task.blockingRequestIds = ids.filter((entry) => entry !== id);
+  const timing = task.phaseTiming;
+  if (!timing) return;
+  timing.blockingRequestIds = [...task.blockingRequestIds];
+  if (!timing.blockingRequestIds.length && !TERMINAL_STATES.includes(task.state)) timing.runningSince = now;
+}
+
+/** Baseline plus anchor: clients advance only the anchor, not server wall time. */
+export function projectPhaseTiming(task: Task, serverNow = new Date().toISOString()): TimingProjection | undefined {
+  const timing = task.phaseTiming;
+  if (!timing) return undefined;
+  return { phase: timing.phase, elapsedMs: timing.elapsedMs, runningSince: timing.runningSince,
+    waiting: timing.blockingRequestIds.length > 0, serverNow };
+}

package/src/state/task-state.ts

@@ -1,5 +1,6 @@
 import type { Task, TaskState } from "../schemas/task.ts";
 import { assertTransition } from "../workflow/transitions.ts";
+import { resetPhaseTiming } from "./phase-timing.ts";
 
 /**
  * Single mutation point for task state. Every state change flows through here
@@ -16,6 +17,7 @@ export function onTransition(fn: TransitionListener): void {
 
 export function transition(task: Task, to: TaskState, now = new Date().toISOString()): void {
   assertTransition(task.state, to);
+  resetPhaseTiming(task, to, now);
   task.state = to;
   task.updatedAt = now;
   listener?.(task, to);

package/src/state/timing-merge.ts

@@ -0,0 +1,25 @@
+import type { PhaseTiming, Task } from "../schemas/task.ts";
+import { blockPhaseTiming, resetPhaseTiming, resolvePhaseTiming } from "./phase-timing.ts";
+
+export interface TimingBaseline { timing?: PhaseTiming; ids: string[] }
+export function timingBaseline(task: Task): TimingBaseline {
+  return { timing: task.phaseTiming ? structuredClone(task.phaseTiming) : undefined,
+    ids: [...(task.blockingRequestIds ?? task.phaseTiming?.blockingRequestIds ?? [])] };
+}
+
+/** Apply only this copy's wait deltas to the authoritative registry and clock. */
+export function mergePhaseTiming(task: Task, baseline: TimingBaseline | undefined, latest: Task): void {
+  const incoming = timingBaseline(task);
+  const oldIds = baseline?.ids ?? incoming.ids;
+  task.blockingRequestIds = [...(latest.blockingRequestIds ?? latest.phaseTiming?.blockingRequestIds ?? [])];
+  if (JSON.stringify(baseline?.timing) !== JSON.stringify(latest.phaseTiming)) {
+    task.phaseTiming = latest.phaseTiming ? structuredClone(latest.phaseTiming) : undefined;
+  }
+  const now = new Date().toISOString();
+  for (const id of oldIds.filter((id) => !incoming.ids.includes(id))) resolvePhaseTiming(task, id, now);
+  for (const id of incoming.ids.filter((id) => !oldIds.includes(id))) blockPhaseTiming(task, id, now);
+  if (task.phaseTiming) task.phaseTiming.blockingRequestIds = [...task.blockingRequestIds];
+  if (task.state !== latest.state || (task.phaseTiming && task.state !== task.phaseTiming.phase)) {
+    resetPhaseTiming(task, task.state, task.updatedAt);
+  }
+}

package/src/webui/api/index.ts

@@ -15,7 +15,7 @@ import { lobbyAbort, lobbyHistory, lobbySend, lobbySnapshot } from "./lobby.ts";
 import { promptsAnswer, promptsDismiss, promptsList } from "./prompts.ts";
 import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave } from "./planner.ts";
 import { quickfixCancel, quickfixList, quickfixMovedToTask, quickfixRunAnyway, quickfixSubmit } from "./quickfix.ts";
-import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore } from "./tasks.ts";
+import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver } from "./tasks.ts";
 import { metricsGet } from "./metrics.ts";
 import { knowledgeAdd, knowledgeComment, knowledgeEdit, knowledgeFiles, knowledgeOpen, knowledgeRemove, knowledgeReplaceFile, knowledgeUnnote } from "./knowledge.ts";
 import { excalidrawAdd, excalidrawCheck, excalidrawCreate, excalidrawList, excalidrawRemove, excalidrawRename, excalidrawReveal, excalidrawToggleAgent, excalidrawToggleAll, excalidrawToggleContribute } from "./excalidraw.ts";
@@ -124,6 +124,22 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksGet(body as { taskId: string }, ctx),
   };
+  routes["tasks.open"] = {
+    schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
+    run: (body, ctx) => tasksOpen(body as { taskId: string }, ctx),
+  };
+  routes["tasks.deliveryReview"] = {
+    schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
+    run: (body, ctx) => tasksDeliveryReview(body as { taskId: string }, ctx),
+  };
+  routes["tasks.deliver"] = {
+    schema: Type.Object({ taskId: TaskId, reviewId: Type.String({ minLength: 1, maxLength: 200 }), action: Type.Union([Type.Literal("create_pr"), Type.Literal("merge_main")]), confirmMain: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
+    run: (body, ctx) => tasksDeliver(body as unknown as Parameters<typeof tasksDeliver>[0], ctx),
+  };
+  routes["tasks.deliveryDefer"] = {
+    schema: Type.Object({ taskId: TaskId, reviewId: Type.String({ minLength: 1, maxLength: 200 }) }, { additionalProperties: false }),
+    run: (body, ctx) => tasksDeliveryDefer(body as { taskId: string; reviewId: string }, ctx),
+  };
   routes["tasks.comments"] = {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksComments(body as { taskId: string }, ctx),

package/src/webui/api/tasks.ts

@@ -15,6 +15,37 @@ import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
 import { taskSteps } from "./plan-facts.ts";
 import type { TaskSection } from "../../lobby/task-rows.ts";
+import { projectPhaseTiming } from "../../state/phase-timing.ts";
+import type { DeliveryRequest } from "../../delivery/operations.ts";
+
+function deliveryTask(body: { taskId: string }, ctx: ApiContext): Task {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,199}$/.test(body.taskId)) fail(400, "bad_request", "invalid task ID");
+  const task = ctx.service.tasks().find((entry) => entry.id === body.taskId);
+  if (!task) fail(404, "not_found", "task not found in this project");
+  if (task.state !== "completed" || !task.delivery) fail(400, "bad_request", "this task has no completed-work delivery review");
+  return task;
+}
+export async function tasksDeliveryReview(body: { taskId: string }, ctx: ApiContext) {
+  deliveryTask(body, ctx);
+  if (!ctx.service.deliveryReview) fail(400, "bad_request", "delivery review is unavailable");
+  try { return { delivery: await ctx.service.deliveryReview(body.taskId) }; }
+  catch (error) { return fail(400, "bad_request", (error as Error).message); }
+}
+export async function tasksDeliver(body: { taskId: string } & DeliveryRequest, ctx: ApiContext) {
+  const task = deliveryTask(body, ctx);
+  if (task.delivery!.reviewId !== body.reviewId) fail(409, "conflict", "review changed; refresh before delivery");
+  if (body.action === "merge_main" && body.confirmMain !== true) fail(400, "bad_request", "confirm that direct merge updates and pushes main");
+  if (!ctx.service.deliveryDeliver) fail(400, "bad_request", "delivery is unavailable");
+  try { return { delivery: await ctx.service.deliveryDeliver(body.taskId, body) }; }
+  catch (error) { return fail(409, "conflict", (error as Error).message); }
+}
+export function tasksDeliveryDefer(body: { taskId: string; reviewId: string }, ctx: ApiContext) {
+  const task = deliveryTask(body, ctx);
+  if (task.delivery!.reviewId !== body.reviewId) fail(409, "conflict", "review changed; refresh before deferring");
+  if (!ctx.service.deliveryDefer) fail(400, "bad_request", "delivery review is unavailable");
+  try { return { delivery: ctx.service.deliveryDefer(body.taskId, body.reviewId) }; }
+  catch (error) { return fail(400, "bad_request", (error as Error).message); }
+}
 
 interface RowContext {
   names: ReadonlyMap<string, string>;
@@ -62,6 +93,8 @@ function rowOf(task: Task, section: TaskSection, ctx: RowContext, sessionId: str
     title: task.title,
     section,
     status: task.state,
+    timing: projectPhaseTiming(task, new Date(now).toISOString()),
+    ...(task.delivery ? { delivery: { status: task.delivery.status, reviewId: task.delivery.reviewId } } : {}),
     ...(task.paused && section !== "recent" ? { paused: true } : {}),
     check: checkOf(task),
     ...(progress ? { progress } : {}),
@@ -94,6 +127,8 @@ function buildRows(tasks: readonly Task[], plans: readonly PlannedTask[], sessio
       title: task.title,
       section: "archived",
       status: task.state,
+      timing: projectPhaseTiming(task, new Date(now).toISOString()),
+      ...(task.delivery ? { delivery: { status: task.delivery.status, reviewId: task.delivery.reviewId } } : {}),
       check: checkOf(task),
       age: ago(now - Date.parse(task.archivedAt ?? task.updatedAt)),
     })),
@@ -125,6 +160,8 @@ export function tasksArchived(ctx: ApiContext): { rows: TaskRow[] } {
     title: task.title,
     section: "archived",
     status: task.state,
+    timing: projectPhaseTiming(task),
+    ...(task.delivery ? { delivery: { status: task.delivery.status, reviewId: task.delivery.reviewId } } : {}),
     check: checkOf(task),
     age: ago(Date.now() - Date.parse(task.archivedAt ?? task.updatedAt)),
   }));
@@ -190,6 +227,19 @@ export function tasksMessage(body: { taskId: string; text: string; attachments?:
   return { notice: ctx.service.sendToTask(body.taskId, withAttachments(body.text, body.attachments, body.taskId, ctx.service.projectRoot?.())) };
 }
 
+/** Select existing owner chat metadata only; never start, claim or switch a process. */
+export function tasksOpen(body: { taskId: string }, ctx: ApiContext): { sessionId?: string; key?: string; notice?: string } {
+  const task = ctx.service.tasks().find((entry) => entry.id === body.taskId);
+  if (!task) fail(404, "not_found", `no task ${body.taskId} in this project`);
+  const sessionId = task.ownerSessionId;
+  if (!sessionId) return { notice: "This task has no owning session. No replacement session was created." };
+  if (sessionId === ctx.service.sessionId()) return { sessionId };
+  const background = ctx.service.sessions().find((entry) => entry.sessionId === sessionId && entry.alive);
+  if (background) return { sessionId, key: background.key };
+  if (ctx.service.liveSessions().some((entry) => entry.sessionId === sessionId)) return { sessionId };
+  return { notice: "The task's owning session has ended or is unavailable. No replacement session was created." };
+}
+
 /** How many recent runs the detail lists (the terminal's count). */
 const DETAIL_RUNS = 6;
 
@@ -206,6 +256,8 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
   const request = taskRequest(found);
   const now = Date.now();
   return {
+    timing: projectPhaseTiming(found, new Date(now).toISOString()),
+    ...(found.delivery ? { delivery: found.delivery } : {}),
     ...(request !== found.title ? { request } : {}),
     ...(!found.plan && found.proposal ? { proposal: found.proposal } : {}),
     ...(found.plan ? { plan: found.plan } : {}),

package/src/webui/protocol.ts

@@ -3,6 +3,8 @@
  * The page imports this file with `import type` only, so nothing from the
  * server is ever bundled into it.
  */
+import type { Delivery, DeliveryAction } from "../delivery/types.ts";
+import type { TimingProjection } from "../state/phase-timing.ts";
 import type { LobbyTopic } from "../lobby/topics.ts";
 import type { WebPrompt } from "../lobby/prompt-hub.ts";
 import type { DialogAnswer, SessionDialog } from "../lobby/sessions.ts";
@@ -338,6 +340,8 @@ export interface ExcalidrawCheck {
 
 /** `tasks.get`: one task read whole, in the terminal's wording. */
 export interface TaskDetail {
+  timing?: TimingProjection;
+  delivery?: Delivery;
   /** The full request, when it says more than the title. */
   request?: string;
   /** The oracle's proposal, while the task has no approved plan yet. */
@@ -519,6 +523,10 @@ export interface Api {
   "tasks.auto": { request: { taskId: string; on: boolean }; result: { notice: string; on: boolean } };
   "tasks.message": { request: { taskId: string; text: string; attachments?: string[] }; result: { notice: string } };
   "tasks.get": { request: { taskId: string }; result: TaskDetail };
+  "tasks.open": { request: { taskId: string }; result: { sessionId?: string; key?: string; notice?: string } };
+  "tasks.deliveryReview": { request: { taskId: string }; result: { delivery: Delivery } };
+  "tasks.deliveryDefer": { request: { taskId: string; reviewId: string }; result: { delivery: Delivery } };
+  "tasks.deliver": { request: { taskId: string; reviewId: string; action: DeliveryAction; confirmMain?: boolean }; result: { delivery: Delivery } };
   "plans.get": { request: { planId: string }; result: PlanDetail };
   "plans.start": { request: { planId: string; where: "here" | "session"; auto?: boolean }; result: { notice: string; key?: string } };
   "plans.discard": { request: { planId: string }; result: { notice: string } };

package/src/workflow/approvals.ts

@@ -1,5 +1,6 @@
 import type { Approval, ApprovalKind, Task } from "../schemas/task.ts";
 import type { Domain } from "../schemas/agent.ts";
+import { blockPhaseTiming, resolvePhaseTiming } from "../state/phase-timing.ts";
 
 /** Record a Worker-requested exception so it blocks further work until resolved. */
 export function requestApproval(
@@ -11,6 +12,7 @@ export function requestApproval(
 ): Approval {
   const approval: Approval = { id: `APR-${task.approvals.length + 1}`, kind, domain, detail, status: "pending", createdAt: now };
   task.approvals.push(approval);
+  blockPhaseTiming(task, `approval:${approval.id}`, now);
   return approval;
 }
 
@@ -30,6 +32,7 @@ export function resolveApproval(
   if (!approval) return undefined;
   approval.status = status;
   approval.note = note;
+  resolvePhaseTiming(task, `approval:${approval.id}`);
   return approval;
 }