@a-t-h-i/bot-lobby 0.6.37 → 0.6.39

package/README.md

@@ -23,8 +23,8 @@ The questionnaire and web tools are built in, so don't also install extensions w
    A plan opens with a short list of steps; the detail of each follows for whoever wants it.
    Plans you leave without saving them as a task wait under **Plan → Previous**. You can read, carry on,
    archive or delete them there. A plan saved as a task leaves that list.
-3. Follow the agents in **Lobby**: the step being worked on reads `active · 1m 12s`, and each task shows
-   how long its agents have worked on it (idle time left out). Models, effort and time limits are in **Settings**.
+3. Follow the agents in **Lobby** and **Tasks**: in a task's steps, the one being worked on reads
+   `active · 1m 12s`, and each task shows how long its agents have worked on it (idle time left out). Models, effort and time limits are in **Settings**.
 
 **Issues** lists the repository's open issues (with `lobby.issues` on), and **Plan it** starts a
 planning session from one. **Git** lists open pull requests; an agent reviews one on request,
@@ -36,6 +36,12 @@ you to confirm merging and pushing main, then removes its worktree after verifyi
 Declining or failed verification keeps the worktree. Delivery can also be reviewed in **Tasks**,
 where you can create a PR instead. The task branch is kept.
 
+Workers never commit; the oracle does. When a task completes, the oracle writes a short commit
+message (a first line of 72 characters or fewer, at most three lines below it). The engine then
+commits only the files that task's workers changed. A quick fix commits its own files when it
+finishes, under the one-line message its agent gives. Changes that were already there before, another
+agent's and anything no agent made are left uncommitted.
+
 New tasks get a short title summarizing the full request, which also names their branch and
 session. Naming uses low reasoning on `classifier.effort.cheapModel` when configured, otherwise
 the session model. If naming fails or takes more than eight seconds, the request's first content
@@ -106,6 +112,18 @@ first, searches the codebase for missing information, and records verified findi
 agent's knowledge. Answers appear in the side pane; the **Chat / Docs** toggle inside the composer
 switches back to the selected document. Questions do not create tasks.
 
+## Scripts
+
+Jobs that come back (seeding data, regenerating fixtures, a set of checks before review) are kept
+as scripts in `.pi/bot-lobby/scripts/`, shared by every agent, so a step done once is run the next
+time instead of being worked out again, which saves tokens and time. Each is named for what it
+does, in snake_case with its language's extension (`seed_public_holidays.py`,
+`run_changed_tests.sh`), and its first lines say what it is for and how to run it. The oracle
+decides when a step is worth a script and saves it (`action=script`); workers only propose one, and
+a replaced script is kept under `archive/`. For each step, Jev picks the scripts that do part of it
+and the agent is told to run them (**Settings → Classifier → Shared scripts**; with Jev off, scripts
+whose names share words with the step are suggested).
+
 ## Keys
 
 The lobby is keyboard-first, and every action button shows its key (`Archive E`, `Delete Del`).
@@ -147,9 +165,10 @@ including startup, tools, retries, children, compaction and reporting. Per-step
 allowances persist across reassignments; only the user can extend them, including
 in auto mode. Waiting for user answers pauses clocks.
 
-The conversation pane groups running agents beneath their current step, for example
-**Step 6 – Implement large feature (6 devs working)**. Queued and finished agents
-are excluded. A child finishing does not complete a checklist step.
+In **Tasks**, a step being worked on shows how many agents are on it, for example
+**Implement large feature (6 agents working)**. Click the count to see which agent is
+doing what, with children under their parent. Queued and finished agents are left out,
+and a child finishing does not complete a checklist step.
 
 The oracle, agents and children compact at settled turn boundaries before context
 reaches 64,000 estimated tokens, or earlier at 60% of the model window or Pi's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.37",
+  "version": "0.6.39",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/prompts/master.md

@@ -319,8 +319,8 @@ the task), or a worktree and branch of its own, and every agent works there.
   Look at the task's files under the worktree path the line names, run git
   there with `git -C "<path>"`, and never edit files outside it: the agents
   already do. Uncommitted changes in the main checkout are not in it.
-- Before `action=complete`, commit the verified task changes on its branch.
-  Stage only this task's files; leave unrelated changes alone. The engine asks
+- `action=complete` commits the task's changes on its branch (see
+  Completion); leave unrelated changes alone. The engine asks
   the user to confirm merging and pushing main and removing the task worktree.
   Let it handle delivery; never merge or remove a worktree yourself.
 - Without a `Git:` line, work as before.
@@ -355,6 +355,31 @@ the relevant knowledge files: omit `taskId` to update project knowledge without
 creating or advancing a task. Answer from saved knowledge first, cite code
 evidence for newly learned facts, and never record a guess.
 
+## Scripts
+
+The project keeps a shared scripts library that every agent can run; your
+prompt lists it under Scripts, and each agent is shown the scripts that fit its
+step. A script saves the tokens and time of working the same job out again, so
+you decide when work becomes one.
+
+- Make a script of a job that will come back in much the same form: seeding or
+  resetting data, regenerating fixtures or generated files, a migration run per
+  environment, a set of checks run before every review, a scaffold. Not of a
+  one-off change, and not of a single command anyone would type.
+- When a step is such a job, say so in its brief: have the worker write the
+  step as a script, drafted in the task's directory under `scripts/`, and run
+  it. Then save it with `action=script`, `name`, `purpose`, `usage` and
+  `file` (the draft), or `text` (the script itself). Read it first: it runs
+  for every agent from then on.
+- Name it for what it does, in snake_case, with its language's extension:
+  `seed_public_holidays.py`, `run_changed_tests.sh`. Prefer the project's own
+  language and runtime. Arguments over hard-coded values, so it serves the
+  next case too; and it says what it did, and fails loudly.
+- Before you brief a step, look for a script that does it, and name it in the
+  brief. To improve one, save it again under the same name; the old version is
+  archived.
+- Workers may propose scripts; take one only when it meets the bar above.
+
 ## Review
 
 The repository state is the source of truth; do not blindly trust Scout or
@@ -408,6 +433,17 @@ fast track: QA has taken part when it is on the roster), critical blockers are
 resolved, and relevant knowledge and decisions are recorded — never just
 because a Worker says it is done.
 
+You commit your agents' work, not they: workers never commit. Call
+`action=complete` with `message`, a commit message you write from what was
+built, and the engine commits exactly the files this task's workers changed
+(never ones that held changes before they started, a quick fix's alone, or
+another task's) before calling the task done. Keep it concise: a first line of
+72 characters or fewer saying what changed, in the imperative ("Add login
+rate limit"), and at most three short lines below it when the why is not
+obvious. No file lists, step-by-step narration, test counts or sign-offs. A
+refused commit (a hook failing, say) leaves the task open: fix the cause and
+complete again.
+
 For an isolated task, `action=complete` automatically reviews delivery and
 asks the user before merging to main and removing its worktree, even in auto
 mode. A decline, missing answer or failed verification preserves the worktree

package/prompts/quickfix.md

@@ -58,3 +58,8 @@ One or two sentences on what changed.
 
 ## Checked
 What you ran and the result, or "not checked" with the reason.
+
+## Commit
+The commit message for your change: one line of 72 characters or fewer
+saying what changed, in the imperative ("Fix the login button's focus ring").
+The engine commits your files with it; do not commit, stage or stash yourself.

package/prompts/worker.md

@@ -99,6 +99,7 @@ repository at the same time, and files are checked out like physical documents:
   nothing else.
 - Verify tests.
 - Update the temporary task scratchpad.
+- Do not commit, stage or stash: the oracle commits the task's work.
 - Report concise results.
 
 ## Pushback
@@ -113,3 +114,14 @@ then add a `## Pushback` block to your output:
 
 The engine records the pushback and blocks that domain until the Master
 resolves it, so be specific and keep working on the rest of the task.
+
+## Shared scripts
+
+Your prompt's Scripts section lists the shared scripts that fit your step. Run
+one instead of doing its work by hand, and check its output as you would your
+own; a script that does not do what it says is a finding for `## Notes`. Do not
+edit the library yourself. When your brief asks you to write a step as a
+script, or you wrote one for a job that will clearly come back, draft it in the
+folder your Workflow Context names for script drafts, named for what it does in snake_case
+(`seed_public_holidays.py`), run it, and propose it under `## Script
+Proposals`.

package/src/classifier/instance.ts

@@ -9,6 +9,8 @@ import { appendMetrics } from "../state/metrics.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { Classifier } from "./classifier.ts";
+import { scriptPicker } from "./scripts.ts";
+import type { ScriptPicker } from "../scripts/pick.ts";
 import { registerJevProvider, type KeySource, type KeyStatus } from "./hosts.ts";
 import { fileHinter, type FileHinter, type FileScope } from "./files.ts";
 import { knowledgePicker, type KnowledgePicker } from "./knowledge.ts";
@@ -46,9 +48,15 @@ export function hintsFor(scope: FileScope): FileHinter {
   return fileHinter(classifier(), scope, (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
 }
 
-/** Relevant knowledge for agents, with what Jev kept of each long file logged to the lobby's activity feed. */
+/** Relevant knowledge and shared scripts for agents, with what Jev kept and matched logged to the lobby's activity feed. */
 export function knowledgeFor(): KnowledgePicker {
-  return knowledgePicker(classifier(), (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
+  const log = (text: string) => lobbyFeed.log("CLASSIFIER", text, "info");
+  return { ...knowledgePicker(classifier(), log), scripts: scriptPicker(classifier(), log) };
+}
+
+/** Shared scripts for a quick fix, with what Jev matched logged to the lobby's activity feed. */
+export function scriptsPickerFor(): ScriptPicker {
+  return scriptPicker(classifier(), (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
 }
 
 /** Triage a request for a task in a tree, logged to the lobby's activity feed; undefined when triage is off or fails. */

package/src/classifier/knowledge.ts

@@ -16,6 +16,7 @@ import { score, selectRelevant, splitSections, tokenize, type KnowledgeInput, ty
 import type { Classifier } from "./classifier.ts";
 import { noul, yesOf, type SystemOneRequest } from "./client.ts";
 import { clip } from "./limits.ts";
+import type { ScriptPicker } from "../scripts/pick.ts";
 
 /** How many characters of each knowledge file a prompt has room for. */
 export const KNOWLEDGE_BUDGET_CHARS = 4000;
@@ -27,7 +28,7 @@ export const MAX_SECTIONS = 60;
 export const KNOWLEDGE_BUDGET_MS = 1500;
 
 /** The three files a prompt carries: `knowledge`, `standards` and `decisions`. */
-export type KnowledgeSlice = keyof KnowledgeSelection;
+export type KnowledgeSlice = Exclude<keyof KnowledgeSelection, "scripts">;
 export type KnowledgePaths = Partial<Record<KnowledgeSlice, string>>;
 
 export interface SectionCall {
@@ -100,9 +101,11 @@ export function leftOutNote(kept: Kept, name: string, path?: string): string {
     : `_Kept ${kept.kept} of ${kept.total} sections of ${name} for this step.${where}_`;
 }
 
-/** Picks what an agent's prompt carries of its knowledge files. */
+/** Picks what an agent's prompt carries of its knowledge files, and of the shared scripts. */
 export interface KnowledgePicker {
   select(task: string, files: KnowledgeInput, options?: { signal?: AbortSignal; paths?: KnowledgePaths }): Promise<KnowledgeSelection>;
+  /** Which shared scripts fit a step; shared words when absent. */
+  scripts?: ScriptPicker;
 }
 
 const SLICES: readonly KnowledgeSlice[] = ["knowledge", "standards", "decisions"];

package/src/classifier/scripts.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared scripts for a step. Jev reads each script's name and purpose against
+ * the step (one yes/no per script) and the ones that do part of it are put in
+ * the agent's prompt with how to run them, so the agent runs the script rather
+ * than working the job out again. A library longer than Jev is asked about is
+ * narrowed by shared words first. Off, failed or out of time, shared words
+ * decide (`scripts/pick.ts`).
+ */
+import type { Classifier } from "./classifier.ts";
+import { noul, yesOf, type SystemOneRequest } from "./client.ts";
+import { clip } from "./limits.ts";
+import { score, tokenize } from "../knowledge/selector.ts";
+import { keywordScripts, MAX_SUGGESTED, type ScriptPicker } from "../scripts/pick.ts";
+import { nameWords, type ScriptEntry } from "../scripts/library.ts";
+
+/** Scripts Jev is asked about for one step. */
+export const MAX_CANDIDATES = 40;
+/** The step waits this long for Jev, then goes with shared words. */
+export const SCRIPTS_BUDGET_MS = 1500;
+
+export interface ScriptCall {
+  request: SystemOneRequest;
+  /** The script each question key stands for. */
+  keys: Map<string, ScriptEntry>;
+}
+
+/** The scripts to ask about: all of them, or the `MAX_CANDIDATES` that share the most words with the step. */
+export function candidateScripts(step: string, entries: readonly ScriptEntry[]): ScriptEntry[] {
+  if (entries.length <= MAX_CANDIDATES) return [...entries];
+  const tokens = tokenize(step);
+  return entries
+    .map((entry, index) => ({ entry, index, hits: score(`${nameWords(entry.name)} ${entry.purpose}`, tokens) }))
+    .sort((a, b) => b.hits - a.hits || a.index - b.index)
+    .slice(0, MAX_CANDIDATES)
+    .map((scored) => scored.entry);
+}
+
+/** One request that asks, for each script, whether it does part of the step. */
+export function scriptRequest(step: string, entries: readonly ScriptEntry[]): ScriptCall {
+  const scripts: Record<string, string> = {};
+  const questions: SystemOneRequest["questions"] = {};
+  const keys = new Map<string, ScriptEntry>();
+  entries.forEach((entry, position) => {
+    const key = `k${position + 1}`;
+    scripts[key] = clip(`${entry.name}: ${entry.purpose}`, 300);
+    questions[key] = noul(`Does the script \`scripts.${key}\` (its file name and purpose) do all or part of \`task\`, so an agent doing the task should run it instead of doing that work by hand? Yes when running it is a step the task needs; no when it is about something else or only shares words with it.`);
+    keys.set(key, entry);
+  });
+  return { request: { state: { task: clip(step, 3000), scripts }, questions }, keys };
+}
+
+/**
+ * A picker on Jev: the scripts it judges to do part of the step, most likely
+ * first. Shared words decide when it is off or cannot judge.
+ */
+export function scriptPicker(classifier: Classifier, log?: (text: string) => void): ScriptPicker {
+  return {
+    async pick(step, entries, options = {}) {
+      if (entries.length === 0) return [];
+      if (!step.trim() || !classifier.enabled("scripts")) return keywordScripts(step, entries);
+      const call = scriptRequest(step, candidateScripts(step, entries));
+      const result = await classifier.ask("scripts", call.request, { ...(options.signal ? { signal: options.signal } : {}), timeoutMs: Math.min(classifier.config.timeoutMs, SCRIPTS_BUDGET_MS) });
+      if (!result) return keywordScripts(step, entries);
+      const judged = [...call.keys].map(([key, entry]) => ({ entry, yes: yesOf(result.answers, key) }));
+      // An answer to none of the questions says nothing: shared words decide.
+      if (judged.every((entry) => entry.yes === undefined)) return keywordScripts(step, entries);
+      const picked = judged
+        .filter((entry) => (entry.yes ?? 0) >= classifier.config.thresholds.scriptRelevantAt)
+        .sort((a, b) => b.yes! - a.yes!)
+        .slice(0, MAX_SUGGESTED)
+        .map((entry) => entry.entry);
+      log?.(`scripts: ${picked.length > 0 ? picked.map((entry) => entry.name).join(", ") : "none"} fit the step (of ${entries.length}) · ${result.ms} ms`);
+      return picked;
+    },
+  };
+}

package/src/execution/agent-runner.ts

@@ -18,6 +18,8 @@ export interface AgentContext {
   standards?: string;
   knowledge?: string;
   decisions?: string;
+  /** The shared scripts that fit the step. */
+  scripts?: string;
   /** Per-agent custom instructions from the global config. */
   instructions?: string;
   workflowContext?: string;

package/src/execution/git.ts

@@ -214,3 +214,66 @@ export async function addedLines(top: string, base: string | undefined, files: r
     return undefined;
   }
 }
+
+/** Longest first line a commit message may have. */
+export const MAX_COMMIT_SUBJECT = 72;
+/** Most lines a commit message may add below its first. */
+export const MAX_COMMIT_BODY_LINES = 3;
+
+/**
+ * A commit message kept short: one first line of at most
+ * `MAX_COMMIT_SUBJECT` characters, then, after a blank line, at most
+ * `MAX_COMMIT_BODY_LINES` short lines. Throws saying what is too long.
+ */
+export function commitMessage(text: string): string {
+  const lines = text.replace(/\r\n?/g, "\n").trim().split("\n").map((line) => line.trimEnd());
+  const subject = lines[0]?.trim() ?? "";
+  if (!subject) throw new Error("the commit message is empty");
+  if (subject.length > MAX_COMMIT_SUBJECT) throw new Error(`the commit message's first line is ${subject.length} characters; keep it to ${MAX_COMMIT_SUBJECT} or fewer, saying what changed`);
+  const body = lines.slice(1).filter((line) => line.trim().length > 0);
+  if (body.length > MAX_COMMIT_BODY_LINES) throw new Error(`the commit message has ${body.length} lines below its first; keep it to ${MAX_COMMIT_BODY_LINES} or fewer`);
+  if (body.some((line) => line.trim().length > MAX_COMMIT_SUBJECT)) throw new Error(`keep each line of the commit message to ${MAX_COMMIT_SUBJECT} characters or fewer`);
+  return body.length > 0 ? `${subject}\n\n${body.map((line) => line.trim()).join("\n")}` : subject;
+}
+
+/** `git status` of `files` (relative to `top`): each changed path with its two-letter code, a rename's old path beside its new one. */
+async function statusOf(top: string, files: readonly string[]): Promise<Array<{ path: string; code: string }>> {
+  if (files.length === 0) return [];
+  const { stdout } = await run("git", ["status", "--porcelain", "-z", "--untracked-files=all", "--", ...files], { cwd: top, maxBuffer: MAX_BUFFER });
+  const entries = stdout.split("\0");
+  const out: Array<{ path: string; code: string }> = [];
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]!;
+    if (entry.length < 4) continue;
+    const code = entry.slice(0, 2);
+    out.push({ path: entry.slice(3), code });
+    if (/[RC]/.test(code) && entries[index + 1]) out.push({ path: entries[++index]!, code: "D " });
+  }
+  return out;
+}
+
+/** Which of `files` (relative to `top`) have changes git has not committed, with a rename's old path beside its new one. */
+export async function uncommitted(top: string, files: readonly string[]): Promise<string[]> {
+  return [...new Set((await statusOf(top, files)).map((entry) => entry.path))];
+}
+
+/**
+ * Commit `files` (relative to `top`) as they stand, and nothing else: what
+ * else is staged stays staged. The commit, or undefined when none of them
+ * has anything to commit. Throws with git's reason when it refuses (a hook).
+ */
+export async function commitFiles(top: string, files: readonly string[], message: string): Promise<{ commit: string; files: string[] } | undefined> {
+  const status = await statusOf(top, files);
+  const dirty = [...new Set(status.map((entry) => entry.path))];
+  if (dirty.length === 0) return undefined;
+  // Only what the working tree holds beyond the index needs adding; a staged deletion is no longer there to add.
+  const unstaged = [...new Set(status.filter((entry) => entry.code[1] !== " ").map((entry) => entry.path))];
+  try {
+    if (unstaged.length > 0) await run("git", ["add", "-A", "--", ...unstaged], { cwd: top, maxBuffer: MAX_BUFFER });
+    await run("git", ["commit", "-q", "-m", message, "--", ...dirty], { cwd: top, maxBuffer: MAX_BUFFER });
+  } catch (error) {
+    const failure = error as { stderr?: string; stdout?: string; message: string };
+    throw new Error(truncate((failure.stderr || failure.stdout || failure.message).trim(), 600));
+  }
+  return { commit: await git(top, ["rev-parse", "HEAD"]), files: dirty };
+}

package/src/knowledge/selector.ts

@@ -9,6 +9,8 @@ export interface KnowledgeSelection {
   knowledge: string;
   standards: string;
   decisions: string;
+  /** The shared scripts that fit the step and how to run them (see `scripts/pick.ts`). */
+  scripts?: string;
 }
 
 export interface KnowledgeInput {

package/src/lobby/quickfix.ts

@@ -21,8 +21,10 @@ import { fellShort, profileLabel, routeLabel, type EffortRoute, type EffortRoute
 import { existsSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
 import type { LintConfig } from "../schemas/configuration.ts";
-import { repositoryTop } from "../execution/git.ts";
+import { changedFiles, commitFiles, commitMessage, MAX_COMMIT_SUBJECT, repositoryTop } from "../execution/git.ts";
 import type { LintExec } from "../execution/lint.ts";
+import { scriptsFor, type ScriptPicker } from "../scripts/pick.ts";
+import { dataRoot } from "../state/project.ts";
 import { lintFeed, runLintGate } from "../workflow/lint.ts";
 
 /** A quick fix edits code, so it gets the full coding tool set. */
@@ -70,6 +72,10 @@ export interface QuickFixJob {
   routed?: boolean;
   /** An earlier run was cut off when pi stopped: some of its edits may already be in the tree. */
   interrupted?: boolean;
+  /** Files (relative to the repository) that had uncommitted changes before its first run: never its to commit. */
+  before?: string[];
+  /** The commit its changes went in, and its message's first line. */
+  commit?: { sha: string; subject: string };
 }
 
 /** How a job enters the queue besides its prompt. */
@@ -105,6 +111,8 @@ export interface QuickFixDeps {
   notify?: (message: string, level: "info" | "warning" | "error") => void;
   /** Likely files for the prompt, and the lookup tool, while the classifier's file hints are on. */
   hints?: FileHinter;
+  /** Which shared scripts fit the request; shared words when absent. */
+  scripts?: ScriptPicker;
   /** Holds a request it judges large (a task, not a quick fix) instead of spending a run on it. */
   classifier?: Classifier;
   /** Lowers thinking or the model for a request the classifier judges simple or trivial. */
@@ -132,6 +140,24 @@ export function quickFixPrompt(instructions?: string): string {
   return custom ? `${loadPrompt("quickfix.md")}\n\n## Custom Instructions\n\n${custom}` : loadPrompt("quickfix.md");
 }
 
+/**
+ * The commit message a quick fix's report gives under `## Commit`, kept short
+ * (see `commitMessage`); the request's first line, clipped, when it gives none
+ * or one too long.
+ */
+export function quickFixCommitMessage(job: Pick<QuickFixJob, "prompt" | "report">): string {
+  const section = /^## Commit[^\n]*\n([\s\S]*?)(?=^## |(?![\s\S]))/m.exec(job.report ?? "")?.[1]?.replace(/^\s*```[^\n]*\n?|```\s*$/g, "").trim();
+  if (section) {
+    try {
+      return commitMessage(section);
+    } catch {
+      // Too long or empty: the request names it instead.
+    }
+  }
+  const title = jobTitle(job).replace(/\s+/g, " ");
+  return title.length > MAX_COMMIT_SUBJECT ? `${title.slice(0, MAX_COMMIT_SUBJECT - 1).trimEnd()}…` : title;
+}
+
 /** First line of a prompt, for lists. */
 export function jobTitle(job: Pick<QuickFixJob, "prompt">): string {
   return job.prompt.split("\n").find((line) => line.trim())?.trim() ?? "(empty)";
@@ -297,13 +323,19 @@ export class QuickFixQueue {
     }
     this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     this.edits.set(job.id, new EditLog(this.deps.cwd));
+    // What was uncommitted before it ran is someone else's; a run cut off and resumed keeps its first look.
+    job.before ??= (await changedFiles(this.deps.cwd))?.files ?? [];
     try {
-      const [likely, route] = await Promise.all([this.likely(job.prompt, controller.signal), this.route(job.prompt, profile, controller.signal)]);
+      const [likely, route, scripts] = await Promise.all([
+        this.likely(job.prompt, controller.signal),
+        this.route(job.prompt, profile, controller.signal),
+        scriptsFor(dataRoot(this.deps.root, this.deps.configDir), job.prompt, this.deps.scripts, controller.signal),
+      ]);
       const quota = { used: MAX_CHILDREN };
       const attempt = (model: string | undefined, thinking: string) => runPiAgent(
         {
           cwd: this.deps.cwd,
-          task: [job.prompt, job.interrupted ? INTERRUPTED_NOTE : "", likely].filter(Boolean).join("\n\n"),
+          task: [job.prompt, job.interrupted ? INTERRUPTED_NOTE : "", likely, scripts ? `## Scripts\n\n${scripts}` : ""].filter(Boolean).join("\n\n"),
           systemPrompt: quickFixPrompt(profile.instructions),
           tools: [...QUICK_FIX_TOOLS, ...(this.deps.hints?.tools() ?? [])],
           ...grantOption("quickfix"),
@@ -355,6 +387,12 @@ export class QuickFixQueue {
       job.error = result.error;
       job.usage = result.usage;
       if (result.model) job.model = result.model;
+      const edited = this.edits.get(job.id)?.list() ?? [];
+      if (job.status === "success" && edited.length > 0) {
+        // Lint reads what changed since HEAD, so it goes before the commit.
+        await this.lintAfter(job, edited);
+        await this.commitAfter(job, edited);
+      }
     } catch (error) {
       job.status = "failed";
       job.error = (error as Error).message;
@@ -432,11 +470,34 @@ export class QuickFixQueue {
     this.deps.feed?.log(QUICK_FIX_SOURCE, `${outcome}: ${jobTitle(job)}`, ok ? "success" : job.status === "cancelled" ? "warning" : "error", job.finishedAt);
     appendMetrics(this.deps.root, this.deps.configDir, [quickFixMetric(job)]);
     this.deps.notify?.(`bot-lobby quick fix ${outcome}: ${jobTitle(job)}`, ok ? "info" : "warning");
-    if (ok && edited.length > 0) void this.lintAfter(job, edited);
     this.changed();
     this.pump();
   }
 
+  /**
+   * Commit what a finished quick fix edited, with the message its report
+   * gives: only its own files, never one that held uncommitted changes before
+   * it ran. A refused commit is a line in the activity log; the fix stands.
+   */
+  private async commitAfter(job: QuickFixJob, edited: readonly string[]): Promise<void> {
+    const top = await repositoryTop(this.deps.cwd);
+    if (!top) return;
+    const before = new Set(job.before ?? []);
+    const files = edited.map((file) => relative(top, file).split("\\").join("/")).filter((file) => file && !file.startsWith("..") && !isAbsolute(file) && !before.has(file));
+    const own = relative(top, dataRoot(this.deps.root, this.deps.configDir)).split("\\").join("/");
+    const ours = own && !own.startsWith("..") ? files.filter((file) => !file.startsWith(`${own}/`)) : files;
+    if (ours.length === 0) return;
+    const message = quickFixCommitMessage(job);
+    try {
+      const commit = await commitFiles(top, ours, message);
+      if (!commit) return;
+      job.commit = { sha: commit.commit, subject: message.split("\n")[0]! };
+      this.deps.feed?.log(QUICK_FIX_SOURCE, `committed ${commit.commit.slice(0, 7)}: ${job.commit.subject}`, "info");
+    } catch (error) {
+      this.deps.feed?.log(QUICK_FIX_SOURCE, `not committed: ${(error as Error).message.split("\n")[0]}`, "warning");
+    }
+  }
+
   /**
    * The lint gate's pass over what a quick fix touched (only problems on the
    * lines it changed are its own): a line in the activity log, never a hold,

package/src/lobby/runtime.ts

@@ -18,7 +18,7 @@ import { modelLookup } from "../pi/tools.ts";
 import { setQuickFixHandoff } from "../pi/route.ts";
 import type { Domain } from "../schemas/agent.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
-import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
+import { classifier, effortFor, hintsFor, scriptsPickerFor } from "../classifier/instance.ts";
 import { checkThinking } from "../pi/model-support.ts";
 import { QuickFixQueue } from "./quickfix.ts";
 import type { Asker } from "../ask/types.ts";
@@ -192,6 +192,7 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
     },
     notify: (message, level) => lobbyNotify(state, message, level),
     hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
+    scripts: scriptsPickerFor(),
     classifier: classifier(),
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
     lint: () => loadConfig().lint,

package/src/master/master.ts

@@ -7,7 +7,9 @@ import { domainSpec } from "../agents/registry.ts";
 import { boundedAgentTime, runAgent, runParallel, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner, type RelayAsk } from "../execution/pi-runner.ts";
 import { knowledgeFilePath, readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
+import { taskDir } from "../knowledge/paths.ts";
 import { selectKnowledge, type KnowledgeSelection } from "../knowledge/selector.ts";
+import { scriptsFor } from "../scripts/pick.ts";
 import { summarizeOutcomes } from "./synthesis.ts";
 import { parseWorkerResult, validateWorkerResult } from "../roles/worker.ts";
 import { parseReviewResult, validateReviewResult } from "../roles/reviewer.ts";
@@ -73,9 +75,14 @@ function knowledgePaths(dataRoots: readonly string[], agent: Domain): KnowledgeP
 /**
  * What an agent's prompt carries of its knowledge for a step: Jev's picks from
  * the files that are too long when a picker is given, the keyword selection
- * otherwise and whenever the picker fails.
+ * otherwise and whenever the picker fails; and the shared scripts that fit it.
  */
 async function pickKnowledge(request: { knowledge?: KnowledgePicker; dataRoots: readonly string[]; signal?: AbortSignal }, agent: Domain, query: string): Promise<KnowledgeSelection> {
+  const [selected, scripts] = await Promise.all([pickFiles(request, agent, query), scriptsFor(request.dataRoots[0], query, request.knowledge?.scripts, request.signal)]);
+  return scripts ? { ...selected, scripts } : selected;
+}
+
+async function pickFiles(request: { knowledge?: KnowledgePicker; dataRoots: readonly string[]; signal?: AbortSignal }, agent: Domain, query: string): Promise<KnowledgeSelection> {
   const slices = readAgentKnowledge(request.dataRoots, agent);
   if (!request.knowledge) return selectKnowledge(query, slices);
   try {
@@ -271,6 +278,7 @@ function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
     request.risk ?? "",
     request.time?.note ?? "",
     request.ask ? askGuidance(request.ask.previews) : "",
+    request.dataRoots[0] ? `Scripts you draft for the shared library go in \`${join(taskDir(request.dataRoots[0], request.taskId), "scripts")}\`.` : "",
   ].filter(Boolean).join("\n\n");
 }
 

package/src/pi/activity.ts

@@ -120,6 +120,8 @@ function orchestrateStep(args: unknown): string {
       return "recording knowledge";
     case "compact":
       return `compacting ${text("file") ?? "knowledge"}`;
+    case "script":
+      return `saving the shared script ${text("name") ?? ""}`.trimEnd();
     case "resolve_approval":
       return `${text("decision") === "rejected" ? "rejecting" : "approving"} ${text("approvalId") ?? "a request"}`;
     case "complete":

package/src/pi/events.ts

@@ -4,6 +4,7 @@ import { detectProjectRoot, loadConfig, readDataRoots } from "../state/project.t
 import { compilePrompt } from "../prompts/compiler.ts";
 import { readAgentKnowledge } from "../knowledge/store.ts";
 import { selectKnowledge } from "../knowledge/selector.ts";
+import { libraryBlock } from "../scripts/pick.ts";
 import { cancelAllRuns } from "../execution/agent-runner.ts";
 import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
@@ -137,7 +138,8 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       else delete event.systemPromptOptions.sections["bot-lobby"];
       return;
     }
-    const slices = readAgentKnowledge(readDataRoots(root, configDir), "master");
+    const dataRoots = readDataRoots(root, configDir);
+    const slices = readAgentKnowledge(dataRoots, "master");
     const selected = selectKnowledge(`${taskRequest(task)} ${task.proposal ?? ""}`, slices);
     event.systemPromptOptions.sections["bot-lobby"] = compilePrompt({
       domain: "master",
@@ -145,6 +147,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       standards: selected.standards,
       knowledge: selected.knowledge,
       decisions: selected.decisions,
+      scripts: dataRoots[0] ? libraryBlock(dataRoots[0]) : "",
       workflowContext: masterWorkflowContext(task, budgetContext(root, configDir, task)),
       instructions: loadConfig().master.instructions,
     });

package/src/pi/plan-checklist.ts

@@ -438,7 +438,8 @@ export function stepWork(steps: readonly string[], runs: readonly AgentRun[], no
     const ms = Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : 0;
     for (const index of covered) {
       if (!run.parentRunId) work[index]!.ms += ms;
-      if (run.status === "running") {
+      // A run that has finished is off the step, whatever its last status said.
+      if (run.status === "running" && !run.finishedAt) {
         work[index]!.active = true;
         work[index]!.activeAgentCount += 1;
         work[index]!.runIds.push(run.runId);

package/src/pi/tools.ts

@@ -59,9 +59,12 @@ const OrchestrateSchema = Type.Object({
     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)" }),
   ),
   roster: Type.Optional(Type.Array(Type.String(), { description: "track: who takes part — any of designer, backend, qa, researcher" })),
-  text: Type.Optional(Type.String({ description: "decide/complete/knowledge: the decision, completion summary, or knowledge text" })),
-  file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md" })),
-  name: Type.Optional(Type.String({ description: "whiteboard: name for the new Excalidraw session" })),
+  text: Type.Optional(Type.String({ description: "decide/complete/knowledge/script: the decision, completion summary, knowledge text, or the script itself" })),
+  message: Type.Optional(Type.String({ description: "complete: the commit message for the agents' changes, which the engine commits (only their files): a first line of 72 characters or fewer saying what changed, at most three short lines below it" })),
+  file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md; script: a script a worker drafted, to save instead of text" })),
+  name: Type.Optional(Type.String({ description: "whiteboard: name for the new Excalidraw session; script: the file name, what it does in snake_case with its language's extension (seed_public_holidays.py, run_changed_tests.sh)" })),
+  purpose: Type.Optional(Type.String({ description: "script: one line on what the script does" })),
+  usage: Type.Optional(Type.String({ description: "script: the command that runs it, with its arguments" })),
   kind: Type.Optional(
     StringEnum(["knowledge", "standard", "decision", "completed"] as const, {
       description: "knowledge: which persistent file the text belongs to",
@@ -76,7 +79,7 @@ const DESCRIPTION = [
   "dependency), propose (record the proposal and request approval), plan (record the internal",
   "plan, or amend it later with the full revised plan), implement (delegate a step to a domain worker, or several domains in parallel with assignments), qa (final quality gate and the only",
   "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), whiteboard (create your own Excalidraw session and assign it to yourself),",
+  "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), whiteboard (create your own Excalidraw session and assign it to yourself),",
   "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",