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

package/src/execution/pi-runner.ts

@@ -8,6 +8,7 @@ import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { activityWord } from "../pi/activity.ts";
+import { skillFiles } from "../pi/grants.ts";
 import { shortDuration } from "../text.ts";
 import { readRelayRequest } from "../ask/relay.ts";
 import type { AskQuestion, AskResult } from "../ask/types.ts";
@@ -39,7 +40,8 @@ export interface PiRunOptions {
   tools?: readonly string[];
   model?: string;
   thinking?: string;
-  timeoutMs: number;
+  /** Names of the skills this agent may load; absent keeps pi's own discovery. */
+  skills?: string[];
   signal?: AbortSignal;
   /** Reports the current one-word tool activity while the agent works. */
   onActivity?: (activity: string) => void;
@@ -53,52 +55,21 @@ export interface PiRunOptions {
   stallTimeoutMs?: number;
   /** Silence allowed while one tool call is in flight (tests, builds); 0 disables. */
   toolStallTimeoutMs?: number;
-  /** Ask the agent to wrap up and report at this elapsed time; 0 disables. */
-  wrapUpAtMs?: number;
   /** Receives the steering handle once the process is running. */
   onStart?: (handle: RunHandle) => void;
-  /** Under a task time budget: when the agent is warned, when its time is up, and who decides on more (see ProcessRunOptions). */
-  time?: TimeLimit;
   /** Answers the agent's relayed questions; without it they are cancelled like any other dialog. */
   onAsk?: RelayAsk;
 }
 
-/**
- * A run's allotted time under a task budget. At `headsUpAtMs` the agent is
- * told how much is left; at `upAtMs` it is steered to stop and report where it
- * left off. Once that report is in (its turn ended), `onTimeUp` decides: more
- * ms keeps the same process going with its context (a follow-up prompt), 0
- * ends it. The hard deadline (`timeoutMs`) and the stall watchdog wait while
- * the decision is pending, and move out with any time granted.
- */
-export interface TimeLimit {
-  /** Reporting time is included in the allowance, including extensions. */
-  hardLimit?: boolean;
-  upAtMs: number;
-  headsUpAtMs?: number;
-  headsUpMessage?: string;
-  upMessage: string;
-  onTimeUp?: (report: string) => Promise<{ extraMs: number; message?: string }>;
-  /** Time the agent gets to write its report after `upAtMs` before it is stopped. */
-  graceMs: number;
-}
-
 export interface ProcessOutcome {
   exitCode: number;
   stdout: string;
   stderr: string;
   killed: boolean;
-  timedOut: boolean;
   /** Killed by the watchdog after going silent. */
   stalled?: boolean;
-  /** The agent was asked to wrap up before its deadline. */
-  wrappedUp?: boolean;
   /** The RPC host rejected the prompt itself. */
   protocolError?: string;
-  /** Stopped at its allotted time and not given more: its report says where it left off. */
-  timeUp?: boolean;
-  /** Time granted past its allotment, in ms. */
-  extendedMs?: number;
 }
 
 /** Streaming agent events forwarded as they arrive on stdout. */
@@ -113,14 +84,9 @@ export type PiStreamEvent =
   | { type: "compaction" }
   | { type: "compaction_end"; error?: string }
   | { type: "usage"; input: number; output: number; cost: number; model?: string }
-  | { type: "wrap_up" }
-  /** Its allotted time is up: it was asked to stop and report where it left off. */
-  | { type: "time_up" }
-  /** It was given `ms` more and carries on. */
-  | { type: "extended"; ms: number }
   /** One finished thinking block, bounded to `MAX_THOUGHT_CHARS`. */
   | { type: "thought"; text: string }
-  /** It asked the user (relayed); its clocks wait until the answers are back. */
+  /** It asked the user (relayed); the stall watchdog waits until the answers are back. */
   | { type: "asking"; questions: number }
   /** The answers went back after `waitedMs` of waiting on the user. */
   | { type: "answered"; waitedMs: number }
@@ -132,7 +98,6 @@ export const MAX_THOUGHT_CHARS = 1500;
 export interface ProcessRunOptions {
   cwd: string;
   signal?: AbortSignal;
-  timeoutMs: number;
   /** The task message sent to the agent over RPC stdin. */
   prompt?: string;
   /** Optional sink for streaming agent events. */
@@ -140,12 +105,7 @@ export interface ProcessRunOptions {
   env?: Record<string, string>;
   stallTimeoutMs?: number;
   toolStallTimeoutMs?: number;
-  wrapUpAtMs?: number;
-  wrapUpMessage?: string;
   onStart?: (handle: RunHandle) => void;
-  /** Grace between the deadline abort and the hard kill. */
-  graceMs?: number;
-  time?: TimeLimit;
   onAsk?: RelayAsk;
 }
 
@@ -162,9 +122,6 @@ export interface PiRunResult {
   usage: { input: number; output: number; cost: number; turns: number };
   model?: string;
   stalled?: boolean;
-  wrappedUp?: boolean;
-  timeUp?: boolean;
-  extendedMs?: number;
 }
 
 export interface ParsedStream {
@@ -179,17 +136,8 @@ const MAX_STREAM_CHARS = 5_000_000;
 const HEARTBEAT_MS = 2000;
 const SETTLE_FALLBACK_MS = 3000;
 const EXIT_DRAIN_MS = 1500;
-const DEADLINE_GRACE_MS = 5000;
 const DIALOG_METHODS = new Set(["select", "confirm", "input", "editor"]);
 
-/** The steering message sent at the wrap-up point. */
-export const WRAP_UP_MESSAGE = [
-  "bot-lobby: you are close to your time limit.",
-  "Stop exploring now. Finish or revert any half-done edit so every file is consistent,",
-  "then write your final report in the required output format.",
-  "List anything unfinished under Blockers or Notes.",
-].join(" ");
-
 /** RPC protocol lines the process host reacts to (never forwarded to the caller). */
 export interface ControlEvent {
   type: string;
@@ -368,10 +316,15 @@ export function finishedThought(line: string): string | undefined {
 export const MCP_RESOURCE_TOOLS: readonly string[] = ["list_mcp_resources", "list_mcp_resource_templates", "read_mcp_resource"];
 
 /** Build the `pi` argv for one isolated, headless RPC agent run; the task goes over stdin. */
-export function buildPiArgs(options: Omit<PiRunOptions, "task"> & { systemPromptFile?: string }): string[] {
+export function buildPiArgs(options: Omit<PiRunOptions, "task"> & { systemPromptFile?: string; skillFiles?: string[] }): string[] {
   const args = ["--mode", "rpc", "--no-session", "--no-prompt-templates", "--no-themes", "--extension", fileURLToPath(new URL("../index.ts", import.meta.url))];
   if (options.model && options.model !== "inherit") args.push("--model", options.model);
   if (options.thinking) args.push("--thinking", options.thinking);
+  // A skill grant replaces pi's own discovery with exactly the granted skills.
+  if (options.skillFiles) {
+    args.push("--no-skills");
+    for (const file of options.skillFiles) args.push("--skill", file);
+  }
   if (options.tools && options.tools.length > 0) {
     // pi keeps every MCP tool under --tools unless an entry names one, so name the granted ones (and the resource
     // tools their servers need), or run without MCP at all when nothing is granted.
@@ -504,19 +457,11 @@ function rpcInput(proc: ChildProcess): { send(command: object): void; close(): v
 
 interface RunState {
   killed: boolean;
-  timedOut: boolean;
   stalled: boolean;
-  wrappedUp: boolean;
   settled: boolean;
   protocolError?: string;
-  /** Told its time is up; its next turn end waits on the decision. */
-  timeUp: boolean;
-  headsUp: boolean;
-  /** Waiting on the decision: the agent is idle, so the deadline and the stall watchdog wait too. */
-  deciding: boolean;
-  /** Relayed questions waiting on the user: every clock and the watchdog wait. */
+  /** Relayed questions waiting on the user: the watchdog waits. */
   asking: number;
-  extendedMs: number;
 }
 
 /** Smallest positive limit, used to pick a watchdog cadence that can see it. */
@@ -528,11 +473,11 @@ function watchInterval(...limits: Array<number | undefined>): number {
 
 /**
  * Default runner: spawn pi in RPC mode, send the task over stdin, and watch it.
- * The child leads its own process group so a stall, deadline or cancel takes
- * its grandchildren (dev servers, watch-mode tests) with it, and the run ends
- * on process exit rather than waiting for a pipe a grandchild may hold open.
- * Near the deadline the agent is steered to wrap up and report; at the
- * deadline it is aborted; after prolonged silence it is killed as stalled.
+ * The child leads its own process group so a stall or cancel takes its
+ * grandchildren (dev servers, watch-mode tests) with it, and the run ends on
+ * process exit rather than waiting for a pipe a grandchild may hold open.
+ * There is no time limit: a run ends when the agent finishes, is cancelled,
+ * or goes silent for so long it is killed as stalled.
  */
 export function spawnPiProcess(args: string[], options: ProcessRunOptions): Promise<ProcessOutcome> {
   return new Promise((resolve) => {
@@ -547,25 +492,16 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       windowsHide: true,
       stdio: ["pipe", "pipe", "pipe"],
     });
-    const state: RunState = { killed: false, timedOut: false, stalled: false, wrappedUp: false, settled: false, timeUp: false, headsUp: false, deciding: false, asking: 0, extendedMs: 0 };
+    const state: RunState = { killed: false, stalled: false, settled: false, asking: 0 };
     const input = rpcInput(proc);
-    const started = Date.now();
-    const time = options.time;
-    // The allotted time counts from here; a grant restarts it.
-    let clockStart = started;
-    let upAtMs = time?.upAtMs ?? 0;
-    let headsUpAtMs = time?.headsUpAtMs ?? 0;
-    let lastOutput = started;
+    let lastOutput = Date.now();
     let quietGraceUntil = 0;
     let toolsInFlight = 0;
     let stderr = "";
     let exitCode: number | undefined;
     let settleTimer: ReturnType<typeof setTimeout> | undefined;
     let done = false;
-    // Time spent waiting on the user's answers is not the agent's: its limits move out by it.
-    let deadlineAt = started + options.timeoutMs;
     let askStarted = 0;
-    let pausedMs = 0;
     const asks = new AbortController();
 
     const onEvent = (event: PiStreamEvent) => {
@@ -574,51 +510,18 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       if (event.type === "retry") quietGraceUntil = Date.now() + event.delayMs;
       options.onEvent?.(event);
     };
-    // A turn that ended after the time ran out waits on the decision; any other ends the run.
+    // The run ends once its turn is over.
     let turnDone = false;
     const turnOver = () => {
       if (turnDone) return;
       turnDone = true;
       clearTimeout(settleTimer);
       settleTimer = undefined;
-      if (state.timeUp && time?.onTimeUp && !done && !state.killed) decide(time.onTimeUp);
-      else input.close();
-    };
-    const decide = (onTimeUp: NonNullable<TimeLimit["onTimeUp"]>) => {
-      state.deciding = true;
-      clearTimeout(deadline);
-      const report = parsePiStream(collector.peek()).text;
-      onTimeUp(report).then(({ extraMs, message }) => {
-        if (done || state.killed) return;
-        state.deciding = false;
-        if (extraMs <= 0) return input.close();
-        // Granted: the same agent carries on where it stopped, its context intact.
-        state.timeUp = false;
-        state.headsUp = false;
-        state.settled = false;
-        state.extendedMs += extraMs;
-        turnDone = false;
-        clockStart = Date.now();
-        lastOutput = clockStart;
-        upAtMs = time?.hardLimit ? Math.max(1, extraMs - Math.min(time.graceMs, Math.floor(extraMs / 4))) : extraMs;
-        // The user just named the time it has: no heads-up quoting the old allotment.
-        headsUpAtMs = 0;
-        const nextLimit = extraMs + (time?.hardLimit ? 0 : time?.graceMs ?? 0);
-        deadlineAt = Date.now() + nextLimit;
-        deadline = setTimeout(onDeadline, nextLimit);
-        input.send({ type: "prompt", message: message ?? "You have more time: carry on from where you left off and finish." });
-        options.onEvent?.({ type: "extended", ms: extraMs });
-      }, () => {
-        state.deciding = false;
-        input.close();
-      });
+      input.close();
     };
     const relay = (id: string | undefined, questions: AskQuestion[], ask: RelayAsk) => {
       state.asking += 1;
-      if (state.asking === 1) {
-        askStarted = Date.now();
-        clearTimeout(deadline);
-      }
+      if (state.asking === 1) askStarted = Date.now();
       options.onEvent?.({ type: "asking", questions: questions.length });
       ask(questions, asks.signal)
         .catch((): AskResult => ({ answers: [], cancelled: true }))
@@ -628,11 +531,7 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
           if (state.asking === 0) {
             const now = Date.now();
             const waited = now - askStarted;
-            pausedMs += waited;
-            deadlineAt += waited;
-            clockStart += waited;
             lastOutput = now;
-            if (!state.deciding) deadline = setTimeout(onDeadline, Math.max(0, deadlineAt - now));
             options.onEvent?.({ type: "answered", waitedMs: waited });
           }
           input.send({ type: "extension_ui_response", id, value: JSON.stringify(result) });
@@ -675,7 +574,6 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
     const finish = (code: number) => {
       if (done) return;
       done = true;
-      clearTimeout(deadline);
       clearTimeout(settleTimer);
       clearInterval(watch);
       // Questions still open when the run ends are put away.
@@ -684,9 +582,8 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       input.close();
       // Reap anything the agent left running in its group.
       if (POSIX) signalGroup(proc, "SIGTERM");
-      const { killed, timedOut, stalled, wrappedUp, protocolError } = state;
-      const timeUp = state.timeUp && !killed;
-      resolve({ exitCode: code, stdout: collector.finish(), stderr, killed, timedOut, stalled, wrappedUp, protocolError, ...(timeUp ? { timeUp } : {}), ...(state.extendedMs > 0 ? { extendedMs: state.extendedMs } : {}) });
+      const { killed, stalled, protocolError } = state;
+      resolve({ exitCode: code, stdout: collector.finish(), stderr, killed, stalled, protocolError });
     };
     const onAbort = () => {
       state.killed = true;
@@ -694,31 +591,9 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       input.close();
       terminate(proc, 3000);
     };
-    const onDeadline = () => {
-      state.killed = true;
-      state.timedOut = true;
-      input.send({ type: "abort" });
-      input.close();
-      setTimeout(() => terminate(proc), options.graceMs ?? DEADLINE_GRACE_MS).unref();
-    };
-    let deadline = setTimeout(onDeadline, options.timeoutMs);
     const watch = setInterval(() => {
-      if (state.killed || done || state.deciding || state.asking > 0) return;
+      if (state.killed || done || state.asking > 0) return;
       const now = Date.now();
-      if (!state.wrappedUp && !state.settled && options.wrapUpAtMs && options.wrapUpAtMs > 0 && now - started - pausedMs >= options.wrapUpAtMs) {
-        state.wrappedUp = true;
-        input.send({ type: "steer", message: options.wrapUpMessage ?? WRAP_UP_MESSAGE });
-        options.onEvent?.({ type: "wrap_up" });
-      }
-      if (time && !state.headsUp && !state.timeUp && !turnDone && headsUpAtMs > 0 && now - clockStart >= headsUpAtMs) {
-        state.headsUp = true;
-        if (time.headsUpMessage) input.send({ type: "steer", message: time.headsUpMessage });
-      }
-      if (time && !state.timeUp && !turnDone && upAtMs > 0 && now - clockStart >= upAtMs) {
-        state.timeUp = true;
-        input.send({ type: "steer", message: time.upMessage });
-        options.onEvent?.({ type: "time_up" });
-      }
       const limit = toolsInFlight > 0 ? options.toolStallTimeoutMs : options.stallTimeoutMs;
       if (limit && limit > 0 && now - Math.max(lastOutput, quietGraceUntil) >= limit) {
         state.killed = true;
@@ -726,7 +601,7 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
         input.close();
         terminate(proc, 3000);
       }
-    }, watchInterval(options.stallTimeoutMs, options.toolStallTimeoutMs, options.wrapUpAtMs, time?.upAtMs, time?.headsUpAtMs));
+    }, watchInterval(options.stallTimeoutMs, options.toolStallTimeoutMs));
     watch.unref();
 
     proc.on("exit", (code, signal) => {
@@ -747,15 +622,11 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
 }
 
 function toResult(parsed: ParsedStream, outcome: ProcessOutcome, aborted: boolean, options: PiRunOptions): PiRunResult {
-  const base = { output: parsed.text, usage: parsed.usage, model: parsed.model, wrappedUp: outcome.wrappedUp === true, ...(outcome.timeUp ? { timeUp: true } : {}), ...(outcome.extendedMs ? { extendedMs: outcome.extendedMs } : {}) };
+  const base = { output: parsed.text, usage: parsed.usage, model: parsed.model };
   if (outcome.stalled) {
     const quiet = shortDuration(options.stallTimeoutMs ?? 0);
     return { ...base, status: "timeout", stalled: true, error: `stalled: no output for ${quiet}` };
   }
-  if (outcome.timedOut) {
-    const note = outcome.wrappedUp ? " after a wrap-up request" : "";
-    return { ...base, status: "timeout", error: `hit the ${shortDuration(options.timeoutMs)} time limit${note}` };
-  }
   if (outcome.killed || aborted || parsed.stopReason === "aborted") {
     return { ...base, status: "cancelled", error: "agent was cancelled" };
   }
@@ -786,23 +657,17 @@ export async function runPiAgent(given: PiRunOptions, run: ProcessRunner = spawn
   try {
     prompt = writePromptFile([options.systemPrompt, host.note].filter(Boolean).join("\n\n"));
     if (options.signal?.aborted) return { status: "cancelled", output: "", usage: { input: 0, output: 0, cost: 0, turns: 0 } };
-    const args = buildPiArgs({ ...options, tools: host.tools, mcpTools: host.mcpTools, systemPromptFile: prompt.file });
+    const args = buildPiArgs({ ...options, tools: host.tools, mcpTools: host.mcpTools, systemPromptFile: prompt.file, ...(options.skills ? { skillFiles: skillFiles(options.skills, options.cwd) } : {}) });
     const outcome = await run(args, {
       cwd: options.cwd,
       signal: options.signal,
-      timeoutMs: options.timeoutMs,
       prompt: `Task: ${options.task}`,
       env: host.env,
       stallTimeoutMs: options.stallTimeoutMs,
       toolStallTimeoutMs: options.toolStallTimeoutMs,
-      wrapUpAtMs: options.wrapUpAtMs,
-      ...(options.time ? { time: options.time } : {}),
       ...(options.onAsk ? { onAsk: options.onAsk } : {}),
       onStart: host.onStart,
       onEvent: (event) => {
-        if (event.type === "asking") host.pause?.();
-        if (event.type === "answered") host.extend?.(event.waitedMs);
-        if (event.type === "extended") host.extend?.(event.ms, true);
         if (event.type === "tool_execution_start") options.onActivity?.(activityWord(event.toolName));
         options.onEvent?.(event);
       },

package/src/index.ts

@@ -21,11 +21,14 @@ import { registerFreshContext } from "./pi/fresh-context.ts";
 import { registerAskTool } from "./ask/tool.ts";
 import { registerWebTools } from "./web/tools.ts";
 import { registerToolBudget } from "./pi/tool-budget.ts";
+import { bindGrants } from "./pi/grants.ts";
 
 export default function (pi: ExtensionAPI): void {
   registerAgentPermissions(pi);
   registerDelegation(pi);
   registerAutoCompaction(pi);
+  // Settings lists this session's MCP tools and skills to grant, and agents find their granted skills through it.
+  if (!isSubagentProcess()) bindGrants(pi);
   let root = detectProjectRoot(process.cwd(), CONFIG_DIR_NAME);
   pi.on("session_start", (_event, ctx) => { root = detectProjectRoot(ctx.cwd, CONFIG_DIR_NAME); });
   // First, so every session_start handler below finds the classifier bound to this session's keys.

package/src/lobby/feed.ts

@@ -266,7 +266,7 @@ export class LobbyFeed {
       if (run.status !== "running") this.settleThought(key);
       if (run.status !== "running" && before !== run.status) {
         this.settle(undefined, key);
-        const kind: ActivityKind = run.status === "success" ? (run.wrappedUp ? "warning" : "success") : run.status === "cancelled" ? "warning" : "error";
+        const kind: ActivityKind = run.status === "success" ? "success" : run.status === "cancelled" ? "warning" : "error";
         this.log(source, `${run.role} ${run.status === "success" ? "finished" : run.status}${run.error ? ` — ${run.error.split("\n")[0]}` : ""}`, kind, at);
       }
     }

package/src/lobby/host.ts

@@ -148,6 +148,8 @@ export interface LobbyService {
   configChanged?(): void;
   /** The models Pi offers, for the settings page's picker. */
   models?(): ModelChoice[];
+  /** The MCP tools and skills pi offers to grant agents, for the settings page. */
+  grants?(): { mcpTools: Array<{ name: string; server: string; description: string; readOnly: boolean }>; skills: Array<{ name: string; description: string; path: string }> };
   /** The classifier models pi can call with its logins, for the classifier's picker. */
   classifierModels?(): Array<{ id: string; label: string }>;
   /** The model this window's session runs on (`provider/id`), when it has one. */

package/src/lobby/planner.ts

@@ -139,7 +139,7 @@ export interface PlannerDeps {
   configDir: string;
   /** The oracle chairing the panel (the Planner settings entry). */
   profile: () => QuickFixProfile;
-  /** A seat's model, thinking and time limit; the oracle's profile when absent. */
+  /** A seat's model, thinking and grants; the oracle's profile when absent. */
   memberProfile?: (member: PanelMember) => QuickFixProfile;
   /** Seats on the panel when the session starts; every seat when absent. */
   panel?: readonly PanelMember[];
@@ -1015,7 +1015,7 @@ export class PlanningSession {
             if (child.status !== "running") this.deps.feed?.end(child.runId, child.status !== "success");
             this.deps.onChange?.();
           },
-          timeoutMs: profile.timeoutMs,
+          ...(profile.skills ? { skills: profile.skills } : {}),
           signal,
           stallTimeoutMs: this.deps.stallTimeoutMs,
           toolStallTimeoutMs: this.deps.toolStallTimeoutMs,

package/src/lobby/pr-review.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 /**
  * Reviewing pull requests from the Git tab. A read-only agent (on QA's model,
- * thinking and time limit) gets the pull request's description, changed files
+ * thinking and grants) gets the pull request's description, changed files
  * and diff from `gh`, may read the repository for context, and writes a
  * review: verdict, summary, findings, tests, questions. Jev can read a pull
  * request first, in a moment, and say whether a full review is worth its
@@ -74,7 +74,7 @@ export interface PullReviewDeps {
   root: string;
   configDir: string;
   exec: Exec;
-  /** QA's model, thinking and time limit, read as a review starts. */
+  /** QA's model, thinking and grants, read as a review starts. */
   profile: () => QuickFixProfile;
   stallTimeoutMs?: number;
   toolStallTimeoutMs?: number;
@@ -285,7 +285,7 @@ export class PullReviews {
           if (child.status !== "running") this.deps.feed?.end(child.runId, child.status !== "success");
           this.deps.onChange?.();
         },
-        timeoutMs: profile.timeoutMs,
+        ...(profile.skills ? { skills: profile.skills } : {}),
         signal,
         stallTimeoutMs: this.deps.stallTimeoutMs,
         toolStallTimeoutMs: this.deps.toolStallTimeoutMs,

package/src/lobby/quickfix.ts

@@ -89,9 +89,10 @@ export interface SubmitOptions {
 export interface QuickFixProfile {
   model?: string;
   thinking: string;
-  timeoutMs: number;
   instructions?: string;
   mcpTools?: string[];
+  /** Skill names it may load; absent keeps every skill pi finds. */
+  skills?: string[];
   /** False when its settings turn the agent's auto-compaction off. */
   autoCompact?: boolean;
   /** Where the job goes when its model runs out of usage or is unavailable. */
@@ -101,7 +102,7 @@ export interface QuickFixDeps {
   cwd: string;
   root: string;
   configDir: string;
-  /** Model, thinking and time limit for the next job, read from settings at start time. */
+  /** Model, thinking and grants for the next job, read from settings at start time. */
   profile: () => QuickFixProfile;
   stallTimeoutMs?: number;
   toolStallTimeoutMs?: number;
@@ -355,7 +356,7 @@ export class QuickFixQueue {
             if (child.status !== "running") this.deps.feed?.end(child.runId, child.status !== "success");
             this.changed();
           },
-          timeoutMs: profile.timeoutMs,
+          ...(profile.skills ? { skills: profile.skills } : {}),
           signal: controller.signal,
           stallTimeoutMs: this.deps.stallTimeoutMs,
           toolStallTimeoutMs: this.deps.toolStallTimeoutMs,

package/src/lobby/recovery.ts

@@ -16,7 +16,6 @@
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { loadTask, ownedTask, saveTask } from "../state/persistence.ts";
 import { resolvePhaseTiming } from "../state/phase-timing.ts";
-import { updateBudget } from "../state/budget.ts";
 import { clearStaleRuns } from "../state/work-time.ts";
 import { livePresence } from "../state/presence.ts";
 import {
@@ -59,8 +58,8 @@ const INTERRUPTED_DECISION = "pi stopped unexpectedly; the task carried on in th
 
 /**
  * Clear what the stopped process left marked as under way on a task: the
- * questions it was waiting on (they no longer wait), the time given to the
- * steps it was running, and the runs it noted as active. A decision records
+ * questions it was waiting on (they no longer wait) and the runs it noted as
+ * active. A decision records
  * the stop, so the task's history says what happened.
  */
 export function settleInterrupted(root: string, configDir: string, taskId: string, now = new Date(), note = INTERRUPTED_DECISION): void {
@@ -71,13 +70,6 @@ export function settleInterrupted(root: string, configDir: string, taskId: strin
   task.decisions.push({ domain: "master", text: note, createdAt: at });
   task.updatedAt = at;
   saveTask(root, configDir, task);
-  updateBudget(root, configDir, taskId, (budget) => {
-    for (const allotment of budget.allotments) {
-      if (allotment.endedAt) continue;
-      allotment.endedAt = at;
-      allotment.outcome = "stopped";
-    }
-  });
   clearStaleRuns(root, configDir, taskId);
 }
 

package/src/lobby/runtime.ts

@@ -126,7 +126,7 @@ function handToQuickFix(state: Runtime, request: string, builder: Domain | undef
   const job = state.quickfix.submit(request, Date.now(), {
     force: true,
     ...(profile ? { profile } : {}),
-    note: `The oracle sent your request here: ${reason.replace(/[.\s]+$/, "")}.${builder ? ` A quick feature: it runs on ${builder === "designer" ? "DESIGN" : "DEV"}'s model, thinking and time limit.` : ""}`,
+    note: `The oracle sent your request here: ${reason.replace(/[.\s]+$/, "")}.${builder ? ` A quick feature: it runs on ${builder === "designer" ? "DESIGN" : "DEV"}'s model, thinking and grants.` : ""}`,
   });
   lobbyTopics.bump("quickfix");
   pushNotice("The oracle sent your request to the quick-fix agent.", "info");

package/src/lobby/service.ts

@@ -47,6 +47,7 @@ import { settleInterrupted, type Relaunch } from "./recovery.ts";
 import { carryOnMessage, resumeRoute, RESUMED_DECISION, type Drivers } from "./resume.ts";
 import { archivePlan as archivePlanOnDisk, deletePlan as deletePlanOnDisk, isPlanId, previousPlans, readPlan, type PlanRecord, type PlanSummary } from "../state/plan-history.ts";
 import { applyMasterModel } from "../pi/model-settings.ts";
+import { grantableSkills, grantableTools } from "../pi/grants.ts";
 import { lobbyTopics } from "./topics.ts";
 import type { LobbyAgentKind, PanelMember } from "../schemas/configuration.ts";
 import type { LiveSession, LobbyService, SwitchTarget } from "./host.ts";
@@ -719,7 +720,7 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
   return `deleted ${taskId} for good`;
 }
 
-/** What a pull request review runs on: QA's model, thinking and time limit. */
+/** What a pull request review runs on: QA's model, thinking and grants. */
 export function reviewProfile(state: Runtime) {
   return resolveReviewProfile(loadConfig(), {
     lookup: modelLookup(state.ctx),
@@ -988,6 +989,7 @@ export function createLobbyService(state: Runtime): LobbyService {
       }
     },
     classifierModels: () => availableClassifiers().map((model) => ({ id: model.id, label: model.label })),
+    grants: () => ({ mcpTools: grantableTools(state.pi), skills: grantableSkills(state.root, state.pi) }),
     issuesEnabled: () => loadConfig().lobby.issues,
     recovered: () => state.recovered,
     seatLabel: (member) => {

package/src/master/goal-check.ts

@@ -8,7 +8,7 @@
 import type { AgentRun } from "../schemas/findings.ts";
 import type { BotLobbyConfig, ProfileResolver } from "../schemas/configuration.ts";
 import { profileFor } from "../schemas/configuration.ts";
-import { runAgent, watchdogOptions, type AgentTime } from "../execution/agent-runner.ts";
+import { runAgent, watchdogOptions } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner } from "../execution/pi-runner.ts";
 import { loadPrompt } from "../prompts/loader.ts";
 import { truncate } from "../text.ts";
@@ -33,11 +33,8 @@ export interface GoalCheckRequest {
   profile?: ProfileResolver;
   signal?: AbortSignal;
   onUpdate?: (run: AgentRun) => void;
-  time?: AgentTime;
 }
 
-/** At most this long: it reads, it does not test. */
-export const GOAL_CHECK_MS = 6 * 60 * 1000;
 /** Most of the change it reads; a longer diff is cut, and the check reads the files it needs. */
 export const GOAL_DIFF_CHARS = 60_000;
 
@@ -106,8 +103,6 @@ export async function runGoalCheck(request: GoalCheckRequest, run: ProcessRunner
     systemPrompt: goalCheckPrompt(profile.instructions),
     ...(profile.model ? { model: profile.model } : {}),
     thinking: profile.thinking,
-    timeoutMs: Math.min(GOAL_CHECK_MS, profile.timeoutMs),
-    ...(request.time ? { time: request.time } : {}),
     cwd: request.cwd,
     ...(request.signal ? { signal: request.signal } : {}),
     ...(request.onUpdate ? { onUpdate: (update: AgentRun) => request.onUpdate!({ ...update, note: update.note ?? "goal check" }) } : {}),