@a-t-h-i/bot-lobby 0.6.53 → 0.6.55

package/src/schemas/configuration.ts

@@ -29,17 +29,18 @@ export interface AgentModelConfig {
   instructions?: string;
   /** Exact native MCP tool names this profile may call; empty grants none. */
   mcpTools?: string[];
-  /** Time limit per run; falls back to `workflow.agentTimeoutMs`. */
-  timeoutMs?: number;
+  /** Names of the skills this agent may load; absent gives it every skill pi finds, empty gives it none. */
+  skills?: string[];
   /** Compact this agent's context on its own as it fills (on unless false); the oracle's also updates the knowledge base. */
   autoCompact?: boolean;
 }
 
-/** Scouts pick a model and a time limit only; their thinking is fixed at `SCOUT_THINKING`. */
+/** Scouts pick a model only; their thinking is fixed at `SCOUT_THINKING`. */
 export interface ScoutConfig {
   mcpTools?: string[];
+  /** See AgentModelConfig.skills. */
+  skills?: string[];
   model: ModelRef;
-  timeoutMs: number;
   /** Tool calls a scout may make: it is told to wrap up at 60% and refused more past this, so it reports with what it has; 0 = no limit. */
   maxToolCalls: number;
   /** Compact a scout's context on its own as it fills (on unless false). */
@@ -74,21 +75,16 @@ export interface WorkflowConfig {
   requireApprovalForFeatures: boolean;
   requireApprovalForDependencies: boolean;
   requireApprovalForArchitectureChanges: boolean;
-  agentTimeoutMs: number;
-  /** Bounded retries for transient agent failures (crash/stall), §59. A spent deadline never retries. */
+  /** Bounded retries for transient agent failures (crash/stall), §59. A cancel never retries. */
   maxAgentRetries: number;
   /** Kill a subagent after this long without any output; 0 disables. */
   stallTimeoutMs: number;
   /** Silence allowed while a single tool call runs (tests, builds); 0 disables. */
   toolStallTimeoutMs: number;
-  /** Fraction of the time limit at which an agent is asked to wrap up and report; 0 disables. */
-  wrapUpAt: number;
   /** Workers that may run at once when the Master delegates several domains together. */
   maxParallelWorkers: number;
   /** The oracle starts each task with a clean context: its model is sent only the conversation since the task started, or since the last one ended. */
   freshContext: boolean;
-  /** Minutes of work time a new task gets unless it is started with its own (`--budget`); 0 = no budget. */
-  taskBudgetMinutes: number;
   /** Small, clear, low-risk requests take the fast track (no scouts, proposal or plan; QA only when tests are needed); false puts every task on the full workflow. */
   fastTrack: boolean;
   /** A delegation that names nothing concrete, or is long without done criteria, is sent back to the oracle once for a fuller brief (sending it again unchanged goes through). */
@@ -101,6 +97,24 @@ export interface WorkflowConfig {
   repoMap: boolean;
   /** A scout asked the same thing again for the same task, on a tree that has not changed, reuses its findings instead of running. */
   reuseScouts: boolean;
+  /** How a parallel batch shares the repository: one checkout with the file desk (`desk`), or a worktree per worker whose changes are merged back when the batch ends (`worktrees`). */
+  parallelMode: ParallelMode;
+  /** The QA gate reviews with a clean context: the request, plan, board contracts and diff, not the workers' own accounts of their work. */
+  cleanReview: boolean;
+  /** Before a task completes, one read-only agent checks the change against the user's original request (not the plan) and names any gap. */
+  goalCheck: boolean;
+  /** Workers may ask a stronger model for advice on a hard step (`ask_expert`), a couple of times per step. */
+  consultExpert: boolean;
+  /** The model `ask_expert` consults; empty uses the oracle's. */
+  expertModel: string;
+}
+
+/** How workers in one parallel batch share the repository. */
+export const PARALLEL_MODES = ["desk", "worktrees"] as const;
+export type ParallelMode = (typeof PARALLEL_MODES)[number];
+
+export function isParallelMode(value: unknown): value is ParallelMode {
+  return typeof value === "string" && (PARALLEL_MODES as readonly string[]).includes(value);
 }
 
 /**
@@ -249,7 +263,7 @@ export interface BotLobbyConfig {
   researcher: AgentModelConfig;
   /** Direct quick fixes from the lobby: no scouting, planning or review. */
   quickFix: AgentModelConfig;
-  /** The task planner that grills the user until a plan is clear; `timeoutMs` bounds one turn. */
+  /** The task planner that grills the user until a plan is clear. */
   planner: AgentModelConfig;
   workflow: WorkflowConfig;
   /** The engine lints the files a task's agents touched, after each step, before QA and at completion. */
@@ -262,34 +276,36 @@ export interface BotLobbyConfig {
 export const DEFAULT_CONFIG: BotLobbyConfig = {
   master: { model: INHERIT_MODEL, thinking: "high", instructions: "" },
   agents: {
-    designer: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "", timeoutMs: 15 * 60 * 1000 },
-    backend: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "", timeoutMs: 15 * 60 * 1000 },
-    qa: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "", timeoutMs: 15 * 60 * 1000 },
+    designer: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "" },
+    backend: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "" },
+    qa: { model: INHERIT_MODEL, thinking: DEFAULT_THINKING, instructions: "" },
   },
-  scout: { model: INHERIT_MODEL, timeoutMs: 8 * 60 * 1000, maxToolCalls: 30 },
-  researcher: { model: INHERIT_MODEL, thinking: "low", instructions: "", timeoutMs: 10 * 60 * 1000 },
-  quickFix: { model: INHERIT_MODEL, thinking: "low", instructions: "", timeoutMs: 10 * 60 * 1000 },
-  planner: { model: INHERIT_MODEL, thinking: "high", instructions: "", timeoutMs: 5 * 60 * 1000 },
+  scout: { model: INHERIT_MODEL, maxToolCalls: 30 },
+  researcher: { model: INHERIT_MODEL, thinking: "low", instructions: "" },
+  quickFix: { model: INHERIT_MODEL, thinking: "low", instructions: "" },
+  planner: { model: INHERIT_MODEL, thinking: "high", instructions: "" },
   workflow: {
     maxReviewIterations: 2,
     maxParallelScouts: 3,
     requireApprovalForFeatures: true,
     requireApprovalForDependencies: true,
     requireApprovalForArchitectureChanges: true,
-    agentTimeoutMs: 15 * 60 * 1000,
     maxAgentRetries: 1,
     stallTimeoutMs: 5 * 60 * 1000,
     toolStallTimeoutMs: 10 * 60 * 1000,
-    wrapUpAt: 0.75,
     maxParallelWorkers: 3,
     freshContext: true,
-    taskBudgetMinutes: 0,
     fastTrack: true,
     briefCheck: true,
     routeQuickFixes: true,
     gitIsolation: "off",
     repoMap: true,
     reuseScouts: true,
+    parallelMode: "desk",
+    cleanReview: true,
+    goalCheck: true,
+    consultExpert: true,
+    expertModel: "",
   },
   lint: { mode: "advise", command: "", extensions: [], timeoutMs: 2 * 60 * 1000 },
   knowledge: {
@@ -345,6 +361,17 @@ function positive(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
 }
 
+/** Skill names as pi writes them (lowercase letters, digits and hyphens); absent when the value is not a list, so the agent keeps every skill. */
+export function normalizeSkills(value: unknown): string[] | undefined {
+  return Array.isArray(value) ? [...new Set(value.filter((name): name is string => typeof name === "string" && /^[a-z0-9][a-z0-9-]{0,63}$/.test(name)))] : undefined;
+}
+
+/** `{ skills }` when an entry names its skills, else nothing. */
+function skillsField(value: unknown): { skills?: string[] } {
+  const skills = normalizeSkills(value);
+  return skills ? { skills } : {};
+}
+
 export function normalizeMcpTools(value: unknown): string[] {
   return Array.isArray(value) ? [...new Set(value.filter((tool): tool is string => typeof tool === "string" && /^mcp__[A-Za-z0-9_]+__[A-Za-z0-9_]+$/.test(tool)))] : [];
 }
@@ -353,20 +380,19 @@ export function normalizeMcpTools(value: unknown): string[] {
 function normalizeAgent(base: AgentModelConfig, override: Partial<AgentModelConfig> | undefined): AgentModelConfig {
   const merged = { ...base, ...(override ?? {}) };
   const thinking = isThinkingLevel(merged.thinking) ? merged.thinking : base.thinking;
-  const timeoutMs = positive(merged.timeoutMs) ?? base.timeoutMs;
   const mcpTools = normalizeMcpTools(merged.mcpTools);
-  return { model: merged.model, thinking, ...(mcpTools.length ? { mcpTools } : {}), ...(typeof merged.instructions === "string" ? { instructions: merged.instructions } : {}), ...(timeoutMs ? { timeoutMs } : {}), ...(merged.autoCompact === false ? { autoCompact: false } : {}) };
+  return { model: merged.model, thinking, ...(mcpTools.length ? { mcpTools } : {}), ...skillsField(merged.skills), ...(typeof merged.instructions === "string" ? { instructions: merged.instructions } : {}), ...(merged.autoCompact === false ? { autoCompact: false } : {}) };
 }
 
-/** Scouts keep a model and a time limit; any thinking value in the file is dropped. */
+/** Scouts keep a model and a tool-call cap; any thinking value in the file is dropped. */
 function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig {
   const base = DEFAULT_CONFIG.scout;
   const mcpTools = normalizeMcpTools(override?.mcpTools);
   return {
     model: typeof override?.model === "string" && override.model.trim() ? override.model : base.model,
-    timeoutMs: positive(override?.timeoutMs) ?? base.timeoutMs,
     maxToolCalls: typeof override?.maxToolCalls === "number" && Number.isFinite(override.maxToolCalls) && override.maxToolCalls >= 0 ? Math.round(override.maxToolCalls) : base.maxToolCalls,
     ...(mcpTools.length ? { mcpTools } : {}),
+    ...skillsField(override?.skills),
     ...(override?.autoCompact === false ? { autoCompact: false } : {}),
   };
 }
@@ -480,8 +506,14 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
   workflow.routeQuickFixes = workflow.routeQuickFixes !== false;
   workflow.repoMap = workflow.repoMap !== false;
   workflow.reuseScouts = workflow.reuseScouts !== false;
+  workflow.parallelMode = isParallelMode(workflow.parallelMode) ? workflow.parallelMode : DEFAULT_CONFIG.workflow.parallelMode;
+  workflow.cleanReview = workflow.cleanReview !== false;
+  workflow.goalCheck = workflow.goalCheck !== false;
+  workflow.consultExpert = workflow.consultExpert !== false;
+  workflow.expertModel = typeof workflow.expertModel === "string" ? workflow.expertModel.trim() : "";
   workflow.gitIsolation = isGitIsolation(workflow.gitIsolation) ? workflow.gitIsolation : DEFAULT_CONFIG.workflow.gitIsolation;
-  workflow.taskBudgetMinutes = typeof workflow.taskBudgetMinutes === "number" && workflow.taskBudgetMinutes > 0 ? Math.min(24 * 60, Math.round(workflow.taskBudgetMinutes)) : 0;
+  // Agent time limits are gone: a config file that still names them is cleaned on its next save.
+  for (const key of ["agentTimeoutMs", "wrapUpAt", "taskBudgetMinutes"]) delete (workflow as unknown as Record<string, unknown>)[key];
   const knowledge = { ...DEFAULT_CONFIG.knowledge, ...(src.knowledge as Partial<KnowledgeConfig> | undefined) };
   const srcAgents = (src.agents ?? {}) as Partial<BotLobbyConfig["agents"]>;
   return {
@@ -509,15 +541,16 @@ export function hasScoutThinking(partial: unknown): boolean {
   return Boolean(scout && typeof scout === "object" && "thinking" in scout);
 }
 
-/** What one subagent run uses: model (undefined = not configured), thinking and time limit. */
+/** What one subagent run uses: model (undefined = not configured), thinking and grants. */
 export interface AgentProfile {
   kind: WorkflowProfileKind;
   model?: string;
   thinking: string;
-  timeoutMs: number;
   instructions?: string;
   /** Exact native MCP tool names this profile may call; empty grants none. */
   mcpTools?: string[];
+  /** Skill names it may load; absent keeps every skill pi finds. */
+  skills?: string[];
   /** False when its settings turn auto-compaction off. */
   autoCompact?: boolean;
 }
@@ -527,6 +560,11 @@ function compactField(entry: { autoCompact?: boolean }): { autoCompact?: false }
   return entry.autoCompact === false ? { autoCompact: false } : {};
 }
 
+/** The MCP tools and skills an entry grants, leaving out what it does not name. */
+function grantFields(entry: { mcpTools?: string[]; skills?: string[] }): { mcpTools?: string[]; skills?: string[] } {
+  return { ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...(entry.skills ? { skills: entry.skills } : {}) };
+}
+
 /** The settings entry a domain/role run draws from. */
 export function profileKind(domain: Domain, role: Role): WorkflowProfileKind {
   if (role === "scout") return "scout";
@@ -539,7 +577,7 @@ function modelOf(ref: ModelRef): string | undefined {
 }
 
 /**
- * Resolve model, thinking and time limit for one run from settings alone.
+ * Resolve model, thinking and grants for one run from settings alone.
  * Workers and the QA gate use their domain's entry, scouts and researchers
  * their own; custom instructions always come from the domain, so a designer
  * scout still carries the designer's house rules.
@@ -547,12 +585,11 @@ function modelOf(ref: ModelRef): string | undefined {
 export function agentProfile(config: BotLobbyConfig, domain: Domain, role: Role): AgentProfile {
   const kind = profileKind(domain, role);
   const instructions = config.agents[domain].instructions;
-  const fallback = config.workflow.agentTimeoutMs;
   if (kind === "scout") {
-    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions, ...(config.scout.mcpTools?.length ? { mcpTools: config.scout.mcpTools } : {}), ...compactField(config.scout) };
+    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, instructions, ...grantFields(config.scout), ...compactField(config.scout) };
   }
   const entry = kind === "researcher" ? config.researcher : config.agents[kind];
-  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
+  return { kind, model: modelOf(entry.model), thinking: entry.thinking, instructions, ...grantFields(entry), ...compactField(entry) };
 }
 
 /** The settings entry of a lobby agent (quick fix or planner). */
@@ -561,22 +598,27 @@ 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; mcpTools?: string[]; autoCompact?: boolean } {
+export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; instructions?: string; mcpTools?: string[]; skills?: string[]; autoCompact?: boolean } {
   const entry = lobbyAgentConfig(config, kind);
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, instructions: entry.instructions, ...grantFields(entry), ...compactField(entry) };
 }
 
 /**
  * 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.
+ * thinking, custom instructions and grants.
  */
-export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[]; autoCompact?: boolean } {
+export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; instructions?: string; mcpTools?: string[]; skills?: string[]; autoCompact?: boolean } {
   const entry = member === "researcher" ? config.researcher : config.agents[member];
-  const timeoutMs = config.planner.timeoutMs ?? config.workflow.agentTimeoutMs;
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, instructions: entry.instructions, ...grantFields(entry), ...compactField(entry) };
+}
+
+/** The model and thinking a worker's `ask_expert` consults: the configured expert, or the oracle's model. */
+export function expertProfile(config: BotLobbyConfig): { model?: string; thinking: string } {
+  const model = config.workflow.expertModel ? modelOf(config.workflow.expertModel) : modelOf(config.master.model);
+  return { ...(model ? { model } : {}), thinking: "high" };
 }
 
-/** Resolves the model, thinking and time limit one subagent run uses. */
+/** Resolves the model, thinking and grants one subagent run uses. */
 export type ProfileResolver = (domain: Domain, role: Role) => AgentProfile;
 
 /** The resolver a request carries, or plain settings when none was supplied (tests, headless use). */

package/src/schemas/findings.ts

@@ -54,10 +54,6 @@ export interface WorkerResult {
   domain: Domain;
   role: "worker";
   completed: string;
-  /** Stopped for time: what it was doing and what is still to do. */
-  leftOff?: string;
-  /** Stopped for time: the minutes it asks for, and why. */
-  moreTime?: { minutes?: number; reason: string };
   filesChanged: FileChange[];
   verification: string;
   notes: string;
@@ -157,8 +153,6 @@ export interface AgentRun {
   thinking?: string;
   /** Killed by the stall watchdog after going silent. */
   stalled?: boolean;
-  /** Asked to wrap up before its deadline; the report may be partial. */
-  wrappedUp?: boolean;
   /** File this worker is queued for at the file desk. */
   waitingFor?: string;
   /** The classifier routed this run down: the configured profile it came from (`p/big · medium`). */
@@ -167,10 +161,4 @@ export interface AgentRun {
   route?: string;
   /** Files the run changed with `edit`/`write`, absolute, across its attempts. */
   edited?: string[];
-  /** Under a task time budget: the time it was given, when that runs out (epoch ms), and any granted since. */
-  allotMs?: number;
-  endsAt?: number;
-  extendedMs?: number;
-  /** Stopped at its allotted time and not given more: its report says where it left off. */
-  timeUp?: boolean;
 }

package/src/schemas/task.ts

@@ -95,7 +95,6 @@ export interface RunLogEntry {
   cost?: number;
   attempts?: number;
   stalled?: boolean;
-  wrappedUp?: boolean;
   error?: string;
   /** The classifier routed this run down from this configured profile. */
   routedFrom?: string;
@@ -279,6 +278,18 @@ export interface Task {
   lintWaiver?: { at: string };
   /** Plan steps the user skipped, each with their reason; the oracle is told not to work on them. */
   skippedSteps?: SkippedStep[];
+  /** The last goal check: the change (by its diff's hash) read against the user's request before completion. */
+  goalCheck?: GoalCheckRecord;
+}
+
+export interface GoalCheckRecord {
+  /** Hash of the diff it read: the same change is not checked twice. */
+  key: string;
+  verdict: "met" | "not_met";
+  gaps: string[];
+  at: string;
+  /** When completion was refused for these gaps: only then can the oracle complete anyway with a reason. */
+  refusedAt?: string;
 }
 
 export function createTask(

package/src/state/metrics.ts

@@ -272,7 +272,7 @@ export interface MetricGroup {
   kinds: MetricKind[];
   runs: number;
   successes: number;
-  /** Runs that stalled or hit their time limit. */
+  /** Runs that stalled. */
   timeouts: number;
   avgMs: number;
   p50Ms: number;

package/src/state/work-clock.ts

@@ -0,0 +1,140 @@
+/**
+ * A task's work clock. Work time counts while the oracle works on the task —
+ * its own turns, which include every agent it runs — and not while it waits
+ * on the user (between turns, and while a dialog is open). It is saved beside
+ * the task's state as work.json (see work-time.ts) by the session that owns
+ * the task. Nothing here limits how long an agent or a task may run.
+ */
+import { clearStaleRuns, updateWork } from "./work-time.ts";
+
+/** `34m`, `1h 05m`. */
+export function formatMinutes(ms: number): string {
+  const minutes = Math.max(0, Math.round(ms / 60_000));
+  if (minutes < 60) return `${minutes}m`;
+  return `${Math.floor(minutes / 60)}h ${String(minutes % 60).padStart(2, "0")}m`;
+}
+
+/* ------------------------------------------------------------ work clock */
+/*
+ * Every task the session drives has a work clock: it keeps the task's work
+ * time (work.json, what the lobby shows as "worked"). It measures; it never
+ * limits how long anything runs.
+ */
+
+interface Clock {
+  root: string;
+  configDir: string;
+  /** The oracle's turn on the task is running. */
+  running: boolean;
+  /** Dialogs open: the user is being asked, so the clock waits. */
+  waits: number;
+  /** Since when the current stretch counts, while it does. */
+  since?: number;
+}
+
+/** Work clocks of the tasks this process drives. */
+const clocks = new Map<string, Clock>();
+/** How often a running clock is saved, so other windows see time pass (and see it is still kept). */
+export const CLOCK_FLUSH_MS = 30_000;
+let flusher: ReturnType<typeof setInterval> | undefined;
+/** The oracle's turn is running in this process. */
+let turn = false;
+
+/** Fold the stretch that counted into the saved totals, and start a new one if it still counts. */
+function settle(taskId: string, clock: Clock, now = Date.now()): void {
+  let spent = 0;
+  if (clock.since !== undefined) {
+    spent = Math.max(0, now - clock.since);
+    clock.since = undefined;
+  }
+  if (clock.running && clock.waits === 0) clock.since = now;
+  const since = clock.since;
+  updateWork(clock.root, clock.configDir, taskId, (work) => {
+    work.workedMs += spent;
+    if (since !== undefined) work.runningSince = new Date(since).toISOString();
+    else delete work.runningSince;
+  }, new Date(now));
+}
+
+function ensureFlusher(): void {
+  if (flusher) return;
+  flusher = setInterval(() => {
+    for (const [taskId, clock] of clocks) if (clock.running) settle(taskId, clock);
+  }, CLOCK_FLUSH_MS);
+  flusher.unref();
+}
+
+/** The oracle's turn started: a task it drives, or starts within the turn, is being worked on. */
+export function turnStarted(): void {
+  turn = true;
+}
+
+/** The oracle started a turn on a task (or took one up within it): its clock runs. */
+export function startClock(root: string, configDir: string, taskId: string): void {
+  let clock = clocks.get(taskId);
+  if (!clock) {
+    clock = { root, configDir, running: false, waits: 0 };
+    clocks.set(taskId, clock);
+    clearStaleRuns(root, configDir, taskId);
+  }
+  if (clock.running) return;
+  clock.running = true;
+  settle(taskId, clock);
+  ensureFlusher();
+}
+
+/**
+ * The task the session drives now, after a step that may have started, ended or taken over one: while
+ * a turn runs, its clock runs and any other task's stops.
+ */
+export function clockTask(root: string, configDir: string, taskId: string | undefined): void {
+  for (const [id, clock] of clocks) {
+    if (id === taskId || !clock.running) continue;
+    clock.running = false;
+    settle(id, clock);
+  }
+  if (taskId && turn) startClock(root, configDir, taskId);
+}
+
+/** The oracle's turn ended: the clocks stop until the next one. */
+export function stopClocks(): void {
+  turn = false;
+  for (const [taskId, clock] of clocks) {
+    if (!clock.running && clock.since === undefined) continue;
+    clock.running = false;
+    settle(taskId, clock);
+  }
+}
+
+/** The user is being asked: every clock waits (nested dialogs each call this and `resumeClocks`). */
+export function pauseClocks(): void {
+  for (const [taskId, clock] of clocks) {
+    clock.waits += 1;
+    settle(taskId, clock);
+  }
+}
+
+export function resumeClocks(): void {
+  for (const [taskId, clock] of clocks) {
+    clock.waits = Math.max(0, clock.waits - 1);
+    settle(taskId, clock);
+  }
+}
+
+/** Run `ask` (a dialog) with every clock stopped: time spent waiting on the user is not the task's. */
+export async function whileAsking<T>(ask: () => Promise<T>): Promise<T> {
+  pauseClocks();
+  try {
+    return await ask();
+  } finally {
+    resumeClocks();
+  }
+}
+
+/** Forget the clocks (tests; a session that ends). */
+export function resetClocks(): void {
+  clocks.clear();
+  turn = false;
+  if (flusher) clearInterval(flusher);
+  flusher = undefined;
+}

package/src/state/work-time.ts

@@ -2,7 +2,7 @@
  * How long a task's agents have actually worked on it, and which worker runs
  * are under way. Work time is the oracle's turns on the task — which include
  * every agent it runs — and not the time it waits on the user (between turns,
- * and while a dialog is open); the work clock in budget.ts measures it. The
+ * and while a dialog is open); the work clock in work-clock.ts measures it. The
  * session that owns the task keeps it beside the task's state as work.json,
  * refreshed while it works, so every window can show the time ticking and
  * mark the steps being worked on. A file its owner stopped refreshing (the
@@ -31,7 +31,6 @@ export interface WorkTime {
   active: ActiveRun[];
   /** When the owning session last wrote it. */
   updatedAt: string;
-  stepLimits?: Record<string, { limitMs: number; usedMs: number }>;
 }
 
 /** The clock as a reader sees it at one moment. */
@@ -51,16 +50,14 @@ export function workPath(root: string, configDir: string, taskId: string): strin
 
 function isWork(value: unknown): value is WorkTime {
   const work = value as Partial<WorkTime> | undefined;
-  return Boolean(work && Number.isFinite(work.workedMs) && typeof work.updatedAt === "string"
-    && (work.stepLimits === undefined || (work.stepLimits !== null && typeof work.stepLimits === "object" && !Array.isArray(work.stepLimits)
-      && Object.values(work.stepLimits).every((entry) => entry && Number.isFinite(entry.limitMs) && Number.isFinite(entry.usedMs) && entry.limitMs >= 0 && entry.usedMs >= 0))));
+  return Boolean(work && Number.isFinite(work.workedMs) && typeof work.updatedAt === "string");
 }
 
 export function readWork(root: string, configDir: string, taskId: string, strict = false): WorkTime | undefined {
   try {
     const value: unknown = JSON.parse(readFileSync(workPath(root, configDir, taskId), "utf8"));
     if (!isWork(value)) throw new Error("Invalid task work record");
-    return { workedMs: value.workedMs, ...(value.runningSince ? { runningSince: value.runningSince } : {}), active: Array.isArray(value.active) ? value.active : [], updatedAt: value.updatedAt, ...(value.stepLimits ? { stepLimits: value.stepLimits } : {}) };
+    return { workedMs: value.workedMs, ...(value.runningSince ? { runningSince: value.runningSince } : {}), active: Array.isArray(value.active) ? value.active : [], updatedAt: value.updatedAt };
   } catch (error) {
     if (strict && (error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
     return undefined;
@@ -80,7 +77,7 @@ export function updateWork(root: string, configDir: string, taskId: string, chan
     renameSync(tmp, path);
   } catch (error) {
     if (strict) throw error;
-    // Display clocks may stop; never overwrite an unreadable allowance ledger.
+    // A display clock may stop; it never holds up the work.
   }
 }
 

package/src/webui/api/index.ts

@@ -21,7 +21,7 @@ import { plansDiscard, plansGet, plansStart } from "./plans.ts";
 import { gitCancelReview, gitJev, gitPull, gitPulls, gitReview } from "./git.ts";
 import { issuesCreate, issuesGet, issuesList } from "./issues.ts";
 import { sessionsAnswer, sessionsArchive, sessionsChat, sessionsList, sessionsMessage, sessionsRename, sessionsStart, sessionsStop, sessionsSwitch } from "./sessions.ts";
-import { settingsGet, settingsLinters, settingsSet } from "./settings.ts";
+import { settingsGet, settingsGrants, settingsLinters, settingsSet } from "./settings.ts";
 import { terminalClose, terminalInput, terminalList, terminalOpen, terminalResize } from "./terminal.ts";
 import { MAX_INPUT_CHARS } from "../terminal.ts";
 import { themesChoose, themesGet, themesRemove, themesRename, themesSave } from "./themes.ts";
@@ -385,6 +385,7 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => settingsSet(body as { patch: Record<string, unknown> }, ctx),
   };
   routes["settings.linters"] = { schema: Empty, run: (_body, ctx) => settingsLinters(ctx) };
+  routes["settings.grants"] = { schema: Empty, run: (_body, ctx) => settingsGrants(ctx) };
   const ThemeId = Type.String({ minLength: 1, maxLength: 40 });
   const ThemeName = Type.String({ minLength: 1, maxLength: 200 });
   const ThemeVars = Type.Optional(Type.Record(Type.String({ maxLength: 60 }), Type.String({ maxLength: 400 })));

package/src/webui/api/settings.ts

@@ -10,7 +10,7 @@ import { lobbyTopics } from "../../lobby/topics.ts";
 import { prefillModels } from "../../pi/model-settings.ts";
 import { kindLabel } from "../../pi/model-support.ts";
 import { pushNotice } from "../notices.ts";
-import type { SettingsInfo, SettingsLinter } from "../protocol.ts";
+import type { SettingsGrants, SettingsInfo, SettingsLinter } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
 import { fail } from "./index.ts";
 
@@ -61,22 +61,6 @@ function checkPort(patch: Record<string, unknown>): void {
   }
 }
 
-function agentEntries(patch: Record<string, unknown>): unknown[] {
-  const agents = isPlain(patch.agents) ? Object.values(patch.agents) : [];
-  return [patch.master, ...agents, patch.researcher, patch.quickFix, patch.planner, patch.scout];
-}
-
-/** Reject a time limit that is not a positive number, . */
-function checkTimeouts(patch: Record<string, unknown>): void {
-  for (const entry of agentEntries(patch)) {
-    const timeout = isPlain(entry) ? entry.timeoutMs : undefined;
-    if (timeout === undefined) continue;
-    if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0) {
-      fail(400, "bad_request", `"${String(timeout)}" is not a positive number of minutes.`);
-    }
-  }
-}
-
 /**
  * The page's first settings call. Subagents never inherit a model silently:
  * any whose model is still unset is pinned to the session's model and saved,
@@ -99,10 +83,14 @@ export function settingsLinters(ctx: ApiContext): { linters: SettingsLinter[] }
   return { linters: ctx.service.linters?.() ?? [] };
 }
 
+/** The MCP tools and skills pi offers now, for each agent's grants. */
+export function settingsGrants(ctx: ApiContext): SettingsGrants {
+  return ctx.service.grants?.() ?? { mcpTools: [], skills: [] };
+}
+
 /** Merge, normalise and save the patch; the lobby rereads the config. */
 export function settingsSet(body: { patch: Record<string, unknown> }, ctx: ApiContext): { config: BotLobbyConfig } {
   checkPort(body.patch);
-  checkTimeouts(body.patch);
   const config = stripSecrets(resolveConfig(mergeConfig(readConfig(ctx), body.patch)));
   writeConfig(ctx, config);
   ctx.service.configChanged?.();

package/src/webui/dev/fake-service.ts

@@ -409,6 +409,20 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     configChanged: () => {},
     models: () => models.map((model) => ({ id: model.id, label: model.label, thinkingLevels: [...model.thinkingLevels] })),
     classifierModels: () => [{ id: "opencode/jev-1.13-free", label: "Jev 1.13 (free)" }, { id: "openrouter/liquid/d1", label: "Liquid D1" }],
+    grants: () => ({
+      mcpTools: [
+        { name: "mcp__github__get_issue", server: "github", description: "Read one issue with its comments.", readOnly: true },
+        { name: "mcp__github__create_pull_request", server: "github", description: "Open a pull request.", readOnly: false },
+        { name: "mcp__github__search_code", server: "github", description: "Search code across repositories.", readOnly: true },
+        { name: "mcp__figma__get_frame", server: "figma", description: "Read a frame's layers and styles.", readOnly: true },
+        { name: "mcp__figma__export_image", server: "figma", description: "Export a frame as PNG or SVG.", readOnly: false },
+      ],
+      skills: [
+        { name: "pdf-tools", description: "Extract text and tables from PDF files.", path: "~/.pi/agent/skills/pdf-tools/SKILL.md" },
+        { name: "release-notes", description: "Write release notes from merged pull requests.", path: ".pi/skills/release-notes/SKILL.md" },
+        { name: "tailwind-review", description: "Check Tailwind classes against the design tokens.", path: ".agents/skills/tailwind-review/SKILL.md" },
+      ],
+    }),
     issuesEnabled: () => fixture.status.issuesEnabled,
     workspace: () => ({ ...fixture.status.workspace }),
     zen: () => ({ ...(fixture.zen.task ? { task: { ...fixture.zen.task } } : {}), runs: [...fixture.zen.runs] }),

package/src/webui/protocol.ts

@@ -210,6 +210,28 @@ export interface SettingsClassifierModel {
   label: string;
 }
 
+/** An MCP tool Settings can grant (`settings.grants`). */
+export interface SettingsMcpTool {
+  name: string;
+  server: string;
+  description: string;
+  /** The server marks it read-only: read-only agents (scouts, QA, researcher) may call it. */
+  readOnly: boolean;
+}
+
+/** A skill Settings can grant (`settings.grants`). */
+export interface SettingsSkill {
+  name: string;
+  description: string;
+  path: string;
+}
+
+/** `settings.grants`: what pi offers to grant agents now. */
+export interface SettingsGrants {
+  mcpTools: SettingsMcpTool[];
+  skills: SettingsSkill[];
+}
+
 /** One message on the event stream (`GET /api/events`, server-sent events). */
 export type StreamEvent =
   | { type: "hello"; versions: Partial<Record<LobbyTopic, number>> }
@@ -606,6 +628,7 @@ export interface Api {
   "settings.get": { request: Record<string, never>; result: SettingsInfo };
   "settings.set": { request: { patch: Record<string, unknown> }; result: { config: BotLobbyConfig } };
   "settings.linters": { request: Record<string, never>; result: { linters: SettingsLinter[] } };
+  "settings.grants": { request: Record<string, never>; result: SettingsGrants };
   "themes.get": { request: Record<string, never>; result: ThemeStoreInfo };
   "themes.save": { request: { name: string; light?: Record<string, string>; dark?: Record<string, string> }; result: ThemeStoreInfo & { id: string } };
   "themes.rename": { request: { id: string; name: string }; result: ThemeStoreInfo };