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

package/src/pi/grants.ts

@@ -0,0 +1,89 @@
+/**
+ * What Settings can grant an agent: the MCP tools pi has connected and the
+ * skills pi finds. The main session's pi is the source (its MCP servers and
+ * skill settings are the user's); a skill grant is kept as names and turned
+ * into files only when an agent starts, so a moved skill still loads.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, loadSkills } from "@earendil-works/pi-coding-agent";
+
+/** An MCP tool an agent can be granted. */
+export interface GrantableTool {
+  name: string;
+  /** The server it comes from (`github` for `mcp__github__get_issue`). */
+  server: string;
+  description: string;
+  /** The server marks it read-only: scouts, QA and the researcher may call it too. */
+  readOnly: boolean;
+}
+
+/** A skill an agent can be granted. */
+export interface GrantableSkill {
+  name: string;
+  description: string;
+  /** Its SKILL.md (or skill file). */
+  path: string;
+}
+
+let source: ExtensionAPI | undefined;
+
+/** Read grants from this session's pi from now on. */
+export function bindGrants(pi: ExtensionAPI): void {
+  source = pi;
+}
+
+/** Forget the session (tests). */
+export function unbindGrants(): void {
+  source = undefined;
+}
+
+function serverOf(name: string): string {
+  return /^mcp__([A-Za-z0-9_]+?)__/.exec(name)?.[1] ?? "";
+}
+
+/** The MCP tools pi has connected, by server then name. */
+export function grantableTools(pi: ExtensionAPI | undefined = source): GrantableTool[] {
+  let tools: ReturnType<ExtensionAPI["getAllTools"]> = [];
+  try {
+    tools = pi?.getAllTools() ?? [];
+  } catch {
+    // Not bound to a running session yet.
+  }
+  return tools
+    .filter((tool) => tool.name.startsWith("mcp__") && tool.exposure !== "hidden")
+    .map((tool) => ({ name: tool.name, server: serverOf(tool.name), description: (tool.description ?? "").split("\n")[0]!.trim(), readOnly: tool.annotations?.readOnlyHint === true }))
+    .sort((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
+}
+
+/**
+ * The skills an agent working in `cwd` would find: the session's own (its
+ * skill commands, which include packages and settings paths) and pi's default
+ * folders for `cwd`, first one per name.
+ */
+export function grantableSkills(cwd: string, pi: ExtensionAPI | undefined = source): GrantableSkill[] {
+  const found = new Map<string, GrantableSkill>();
+  try {
+    for (const command of pi?.getCommands() ?? []) {
+      if (command.source !== "skill") continue;
+      const name = command.name.replace(/^skill:/, "");
+      if (!found.has(name)) found.set(name, { name, description: command.description ?? "", path: command.sourceInfo.path });
+    }
+  } catch {
+    // Not bound to a running session yet.
+  }
+  try {
+    for (const skill of loadSkills({ cwd, agentDir: getAgentDir(), skillPaths: [], includeDefaults: true }).skills) {
+      if (!found.has(skill.name)) found.set(skill.name, { name: skill.name, description: skill.description, path: skill.filePath });
+    }
+  } catch {
+    // An unreadable skill folder grants nothing.
+  }
+  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** The files of the granted skills that still exist; a name pi no longer finds is left out. */
+export function skillFiles(names: readonly string[], cwd: string): string[] {
+  if (names.length === 0) return [];
+  const byName = new Map(grantableSkills(cwd).map((skill) => [skill.name, skill.path]));
+  return names.flatMap((name) => byName.get(name) ?? []);
+}

package/src/pi/model-settings.ts

@@ -24,12 +24,11 @@ export interface EntryView {
   model: string;
   thinking?: string;
   instructions?: string;
-  timeoutMs?: number;
 }
 
 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 };
+  if (kind === "scout") return { model: config.scout.model };
   if (kind === "researcher") return config.researcher;
   if (kind === "quickfix") return config.quickFix;
   if (kind === "planner") return config.planner;
@@ -40,14 +39,13 @@ interface EntryPatch {
   model?: string;
   thinking?: string;
   instructions?: string;
-  timeoutMs?: number;
 }
 
 /** 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 = { ...config.master, ...patch } as AgentModelConfig;
-  else if (kind === "scout") next.scout = { ...config.scout, model: patch.model ?? config.scout.model, timeoutMs: patch.timeoutMs ?? config.scout.timeoutMs };
+  else if (kind === "scout") next.scout = { ...config.scout, model: patch.model ?? config.scout.model };
   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;

package/src/pi/model-support.ts

@@ -1,6 +1,7 @@
 import { clampThinkingLevel, getSupportedThinkingLevels, type Api, type Model, type ModelThinkingLevel } from "@earendil-works/pi-ai";
 import {
   agentProfile,
+  expertProfile,
   isThinkingLevel,
   lobbyAgentProfile,
   panelMemberProfile,
@@ -90,7 +91,7 @@ export function createProfileResolver(config: BotLobbyConfig, options: ResolverO
   };
 }
 
-type RunProfile = { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[] };
+type RunProfile = { model?: string; thinking: string; instructions?: string; mcpTools?: string[]; skills?: 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 {
@@ -106,23 +107,29 @@ function resolveRunProfile(profile: RunProfile, label: string, options: Resolver
   return { ...profile, model, thinking: check.level };
 }
 
-/** A lobby agent's model, thinking and time limit. */
+/** The model ask_expert consults on: the expert setting's, else the oracle's, else the session's; thinking clamped to it. */
+export function resolveExpertProfile(config: BotLobbyConfig, options: ResolverOptions): { model?: string; thinking: string } {
+  const { model, thinking } = resolveRunProfile(expertProfile(config), "Expert consult", options);
+  return { ...(model ? { model } : {}), thinking };
+}
+
+/** A lobby agent's model, thinking and grants. */
 export function resolveLobbyProfile(config: BotLobbyConfig, kind: LobbyAgentKind, options: ResolverOptions): RunProfile {
   return resolveRunProfile(lobbyAgentProfile(config, kind), kindLabel(kind), options);
 }
 
-/** A planning panel seat's model, thinking and time limit, from its domain's (or the researcher's) settings. */
+/** A planning panel seat's model, thinking and grants, from its domain's (or the researcher's) settings. */
 export function resolvePanelProfile(config: BotLobbyConfig, member: PanelMember, options: ResolverOptions): RunProfile {
   return resolveRunProfile(panelMemberProfile(config, member), kindLabel(member), options);
 }
 
 /**
- * The model, thinking and time limit a pull request review runs on: QA's, the
+ * The model, thinking and grants a pull request review runs on: QA's, the
  * agent whose job is judging work, with its custom instructions.
  */
 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 } : {}) }, kindLabel("qa"), options);
+  return resolveRunProfile({ model: profile.model, thinking: profile.thinking, ...(profile.instructions ? { instructions: profile.instructions } : {}), ...(profile.mcpTools ? { mcpTools: profile.mcpTools } : {}), ...(profile.skills ? { skills: profile.skills } : {}) }, kindLabel("qa"), options);
 }
 
 /** Every configured subagent whose thinking level its model does not support, for `/bot-lobby config`. */

package/src/pi/route.ts

@@ -27,7 +27,7 @@ export const ROUTE_TOOL = "route_request";
 /**
  * Hands a request to the lobby's quick-fix agent and shows the Quick fix tab;
  * the job's id, or undefined without a lobby. `builder` is set for a quick
- * feature: it runs on that domain's model, thinking and time limit.
+ * feature: it runs on that domain's model, thinking and grants.
  */
 export type QuickFixHandoff = (request: string, builder: Domain | undefined, reason: string) => string | undefined;
 

package/src/pi/run-summary.ts

@@ -51,21 +51,19 @@ const STATUS_ICONS: Record<AgentRun["status"], string> = {
 };
 
 /** Why a run ended the way it did, in words, when that is not plain success. */
-export function runFlags(run: Pick<AgentRun, "status" | "stalled" | "wrappedUp" | "attempts" | "route">): string[] {
+export function runFlags(run: Pick<AgentRun, "status" | "stalled" | "attempts" | "route">): string[] {
   const flags: string[] = [];
   if (run.route) flags.push(`routed ${run.route}`);
-  if (run.stalled) flags.push("stalled");
-  else if (run.status === "timeout") flags.push("hit its time limit");
+  if (run.stalled || run.status === "timeout") flags.push("stalled");
   else if (run.status === "failed") flags.push("failed");
   else if (run.status === "cancelled") flags.push("cancelled");
-  if (run.wrappedUp) flags.push(run.status === "success" ? "wrapped up early — report may be partial" : "asked to wrap up");
   if (run.attempts > 1) flags.push(`${run.attempts} attempts`);
   return flags;
 }
 
 /**
  * `✓ DEV worker · 3m 12s · 9 turns · 23 tools · 41k↑ 6k↓ · $0.12 · provider/model`,
- * followed by any flags (stalled, time limit, wrapped up early, attempts).
+ * followed by any flags (stalled, failed, cancelled, attempts).
  */
 export function describeRun(run: AgentRun, now = Date.now()): string {
   const parts = [`${STATUS_ICONS[run.status]} ${agentName(run)} ${run.role}`, shortDuration(durationOf(run, now))];
@@ -101,7 +99,6 @@ export function runLogEntry(run: AgentRun): RunLogEntry {
     ...(run.usage ? { input: run.usage.input, output: run.usage.output, cost: run.usage.cost } : {}),
     attempts: run.attempts,
     ...(run.stalled ? { stalled: true } : {}),
-    ...(run.wrappedUp ? { wrappedUp: true } : {}),
     ...(run.error ? { error: run.error.split("\n")[0]!.slice(0, 200) } : {}),
     ...(run.routedFrom ? { routedFrom: run.routedFrom } : {}),
   };
@@ -129,7 +126,6 @@ export function runFromLog(entry: RunLogEntry, taskId: string): AgentRun {
     ...(entry.tools ? { tools: entry.tools } : {}),
     ...(entry.input !== undefined ? { usage: { input: entry.input, output: entry.output ?? 0, cost: entry.cost ?? 0, turns: entry.turns ?? 0 } } : {}),
     ...(entry.stalled ? { stalled: true } : {}),
-    ...(entry.wrappedUp ? { wrappedUp: true } : {}),
     ...(entry.error ? { error: entry.error } : {}),
   };
 }

package/src/pi/start-flags.ts

@@ -1,10 +1,10 @@
 /**
  * The flags that lead a task's request: `--task` (always a task), `--auto`,
- * `--fast`, `--full`, `--branch`, `--worktree`, `--no-branch` and
- * `--budget <time>` (or `--budget=<time>`). The command parses them; a session
+ * `--fast`, `--full`, `--branch`, `--worktree` and `--no-branch`. The
+ * command parses them; a session
  * started from the lobby is named from what follows them.
  */
-export const START_FLAG = /^--(task|auto|fast|full|branch|worktree|no-branch)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
+export const START_FLAG = /^--(task|auto|fast|full|branch|worktree|no-branch)(?=\s|$)\s*/;
 
 /** The request without its leading flags. */
 export function stripStartFlags(text: string): string {

package/src/pi/start-task.ts

@@ -21,7 +21,6 @@ import { setAutoMode } from "../state/auto.ts";
 import { listPlannedTasks, loadPlannedTask, markPlannedTaskStarted, plannedTaskRequest, type PlannedTask } from "../state/backlog.ts";
 import { triageFor } from "../classifier/instance.ts";
 import { freshContextOn, markContext } from "./fresh-context.ts";
-import { setBudget } from "../state/budget.ts";
 import { createWorkspace, gitLine } from "../execution/workspace.ts";
 import type { GitIsolation } from "../schemas/configuration.ts";
 
@@ -75,7 +74,7 @@ function plannedSteps(task: Task): string[] {
   ].filter(Boolean);
 }
 
-export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: boolean; routed?: boolean } = {}): string {
+export function kickoff(task: Task, options: { fastTrack?: boolean; routed?: boolean } = {}): string {
   const track = task.track;
   const head = [
     `A bot-lobby task is active: ${task.id}`,
@@ -84,7 +83,6 @@ export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: bo
     `State: ${task.state}`,
     ...(options.routed ? [ROUTED_LINE] : []),
     ...(track ? [trackSummary(track)] : []),
-    ...(budgetMinutes > 0 ? [`Time budget: ${budgetMinutes} minutes of work, for you and every agent. Size the plan to fit it and divide it by scope (see Time budget in your prompt).`] : []),
     ...(task.git ? [gitLine(task.git)] : []),
     "",
   ];
@@ -135,8 +133,6 @@ export interface StartOptions {
   auto?: boolean;
   /** The task's short title (a planned task's own title); derived from the request otherwise. */
   title?: string;
-  /** Minutes of work time the task gets; `workflow.taskBudgetMinutes` when absent. */
-  budget?: number;
   /** The user's `--fast` or `--full`: the path the task takes, whatever its request reads as. */
   track?: TrackPath;
   /** The classifier already read the request (routing did): `triage` is its read, or absent when it was off. */
@@ -177,8 +173,6 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   if (options.approvedPlan && options.plan) startFromAgreedPlan(task, options.plan, taskDirFor(root, configDir, task.id));
   await giveWorkspace(ctx, root, configDir, task, options.isolation ?? config.workflow.gitIsolation);
   saveTask(root, configDir, task);
-  const budgetMinutes = options.budget ?? config.workflow.taskBudgetMinutes;
-  if (budgetMinutes > 0) setBudget(root, configDir, task.id, budgetMinutes);
   if (options.auto) setAutoMode(root, configDir, task.id, true, sessionId);
   // A session that starts a task is named after it (its friendly name), so /resume and the lobby list it by name.
   if (!pi.getSessionName() || pi.getSessionName() === taskName(request)) pi.setSessionName(task.id);
@@ -188,7 +182,7 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   // The oracle takes the task on with a clean context: nothing said before the kickoff is sent to its model.
   if (freshContextOn()) markContext(pi, { kind: "start", taskId: task.id, at: Date.now() });
   // A kickoff while pi is still busy (another turn) queues behind it instead of throwing.
-  pi.sendUserMessage(kickoff(task, budgetMinutes, { fastTrack: config.workflow.fastTrack, ...(options.routed ? { routed: true } : {}) }), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+  pi.sendUserMessage(kickoff(task, { fastTrack: config.workflow.fastTrack, ...(options.routed ? { routed: true } : {}) }), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
   return task;
 }
 

package/src/pi/tools.ts

@@ -8,12 +8,12 @@ import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { classifier, effortFor, hintsFor, knowledgeFor, triageFor } from "../classifier/instance.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
-import { whileAsking } from "../state/budget.ts";
+import { whileAsking } from "../state/work-clock.ts";
 import { askChoice, askText, askUser, canAsk } from "../ask/web.ts";
 import type { AskQuestion } from "../ask/types.ts";
 import { unescapeBreaks } from "../lobby/blocks.ts";
 import { isQuiet } from "./quiet.ts";
-import { checkThinking, createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
+import { checkThinking, createProfileResolver, modelRef, resolveExpertProfile, type ModelLookup } from "./model-support.ts";
 import { agentName, describeRun } from "./run-summary.ts";
 import { lintFeed } from "../workflow/lint.ts";
 import { qaRiskLine } from "../classifier/qa-risk.ts";
@@ -43,18 +43,16 @@ const OrchestrateSchema = Type.Object({
       Type.Object({
         domain: Type.String({ description: "designer, backend, or qa" }),
         task: Type.String({ description: "a self-contained brief for that domain's worker: Goal, exact Files, numbered What to do, Contracts (in full), Constraints, Done when, If stuck. No assumptions" }),
-        minutes: Type.Optional(Type.Number({ description: "under a time budget: minutes for this worker, by its scope" })),
       }),
       { description: "implement: run several domains in parallel (distinct domains); workers share files through the file desk" },
     ),
   ),
-  minutes: Type.Optional(Type.Number({ description: "implement (under a time budget): minutes for this step, by its scope; budget: more minutes to ask the user for" })),
   approvalId: Type.Optional(Type.String({ description: "resolve_approval: the approval id from a worker result" })),
   decision: Type.Optional(
     StringEnum(["approved", "rejected"] as const, { description: "resolve_approval: approve or reject the request" }),
   ),
   note: Type.Optional(Type.String({ description: "resolve_approval: rationale, or what to do instead when rejected" })),
-  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue; budget: why the task needs more time; track: why the task takes that path or needs those members" })),
+  reason: Type.Optional(Type.String({ description: "block: why the task cannot continue; track: why the task takes that path or needs those members; complete: why gaps the goal check named are deliberate (the user agreed)" })),
   track: Type.Optional(
     StringEnum(["fast", "full"] as const, { description: "track: fast (straight to the roster's agents, no scouts, proposal or plan; QA only for tests) or full (the whole workflow)" }),
   ),
@@ -81,8 +79,8 @@ const DESCRIPTION = [
   "review), knowledge (record approved project knowledge or a decision; works without a task),",
   "compact (replace a knowledge file with a rewritten version, archiving the old one; works without a task; disperse domain-relevant facts to action=knowledge (domain=designer|backend|qa) first), script (save a script to the shared scripts library, or replace one, for a job that comes back; works without a task),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
-  "pass, then ask the user to confirm merging and pushing main and removing its worktree), block/resume (escalate or continue), budget (under a time budget: where it stands, or ask the",
-  "user for more minutes with a reason), track (the task's path and who takes part: show it, or correct it with",
+  "pass, then ask the user to confirm merging and pushing main and removing its worktree), block/resume (escalate or continue),",
+  "track (the task's path and who takes part: show it, or correct it with",
   "track=fast|full, roster and a reason), status, cancel.",
   "Every instruction you give an agent is read by a possibly smaller, cheaper model that cannot infer intent: write each one as a complete, explicit brief with the goal, files, actions, contracts, constraints and done criteria, then check the report against it.",
   "The engine validates every step against the task state machine, so a rejected action means the workflow is not at that step yet.",
@@ -121,6 +119,7 @@ export function workflowDeps(
       sessionModel: ctx.model ? modelRef(ctx.model) : undefined,
       warn,
     }),
+    expert: resolveExpertProfile(config, { lookup: modelLookup(ctx), sessionModel: ctx.model ? modelRef(ctx.model) : undefined, warn }),
     sessionId: ctx.sessionManager.getSessionId(),
     signal,
     onUpdate,
@@ -130,7 +129,7 @@ export function workflowDeps(
     classifier: classifier(),
     triage: (request, triageSignal) => triageFor({ cwd: ctx.cwd, root, configDir }, request, triageSignal),
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
-    // Time spent waiting on the user is not the task's: its budget clock waits too.
+    // Time spent waiting on the user is not the task's: its work clock waits too.
     // The questions go to the web page, where a free-text answer may run to several lines.
     ask: async (question) => (canAsk() ? whileAsking(() => askText(question, undefined, ctx)) : undefined),
     choose: async (title, options) => (canAsk() ? whileAsking(() => askChoice(title, options, undefined, ctx)) : undefined),
@@ -189,14 +188,13 @@ function registerBotLobbyEntries(pi: ExtensionAPI): void {
   });
 }
 
-/** A transcript line per finished run, plus a warning for anything that stalled or ran out of time. */
+/** A transcript line per finished run, plus a warning for anything that stalled. */
 function reportFinishedRuns(pi: ExtensionAPI, ctx: ExtensionContext, result: WorkflowResult): void {
   for (const run of result.runs ?? []) {
-    const ok = run.status === "success" && !run.wrappedUp;
+    const ok = run.status === "success";
     pi.appendEntry("bot-lobby", { kind: "run", taskId: result.taskId, text: describeRun(run), ok });
     if (!ctx.hasUI) continue;
-    if (run.stalled) ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} stalled — ${run.error ?? "no output"}`, "warning");
-    else if (run.status === "timeout") ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} ${run.error ?? "hit its time limit"}`, "warning");
+    if (run.stalled || run.status === "timeout") ctx.ui.notify(`bot-lobby: ${agentName(run)} ${run.role} stalled — ${run.error ?? "no output"}`, "warning");
   }
 }
 

package/src/roles/worker.ts

@@ -26,8 +26,6 @@ export const workerSpec: RoleSpec = {
     "the matching section instead. Do not narrate. Report only what you actually changed and verified.",
     "An optional `## Pushback` (`**Request:**`, `**Reason:**`, optional `**Alternative:**`) states a change you",
     "believe is wrong, with your reason, instead of doing it; still complete everything else you safely can.",
-    "Stopped because your time is up, also add `## Left Off` (what you were doing, what is still to do) and",
-    "`## More Time` (`N minutes — why`).",
   ].join(" "),
 };
 
@@ -80,15 +78,6 @@ export function parseBlockers(
   ];
 }
 
-/** `## More Time` as the minutes asked for (`15 minutes`, `1h`, `20m`) and the reason given. */
-export function parseMoreTime(text: string): { minutes?: number; reason: string } {
-  const flat = text.replace(/^[-*]\s*/gm, "").replace(/\s+/g, " ").trim();
-  const match = /(\d+(?:\.\d+)?)\s*(h|hrs?|hours?|m|mins?|minutes?)\b/i.exec(flat);
-  const minutes = match ? Math.round(Number(match[1]) * (/^h/i.test(match[2]!) ? 60 : 1)) : undefined;
-  const reason = match ? flat.slice(match.index + match[0].length).replace(/^\s*(?:—|–|-|:|,|because|to)?\s*/i, "").trim() : flat;
-  return { ...(minutes && minutes > 0 ? { minutes } : {}), reason: reason || flat };
-}
-
 /** A bullet that says there is nothing: `None.`, `N/A`, `No new dependencies (three.js from a CDN)`. */
 const NOTHING = /^(?:\*\*|_)?(?:none|n\/?a|nil|nothing|not applicable|no(?:ne)?\s+(?:new\s+|additional\s+|extra\s+)?(?:dependenc|packages?|librar|architecture|architectural|changes?\b))/i;
 
@@ -104,7 +93,6 @@ export function parseWorkerResult(domain: Domain, raw: string, now = new Date().
     domain,
     role: "worker",
     completed: findSection(sections, "completed") ?? "",
-    ...leftOffFields(sections),
     filesChanged: bullets(findSection(sections, "files changed")).map((entry): FileChange => {
       const file = parseFileBullet(entry);
       return { path: file.path, change: file.reason };
@@ -121,12 +109,6 @@ export function parseWorkerResult(domain: Domain, raw: string, now = new Date().
   };
 }
 
-function leftOffFields(sections: Map<string, string>): Pick<WorkerResult, "leftOff" | "moreTime"> {
-  const leftOff = findSection(sections, "left off")?.trim();
-  const more = findSection(sections, "more time")?.trim();
-  return { ...(leftOff ? { leftOff } : {}), ...(more ? { moreTime: parseMoreTime(more) } : {}) };
-}
-
 /** Report contract deviations so the Master does not accept unverified work. */
 export function validateWorkerResult(result: WorkerResult): string[] {
   const issues: string[] = [];