@a-t-h-i/bot-lobby 0.6.38 → 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
@@ -159,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.38",
+  "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.
@@ -433,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

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/lobby/quickfix.ts

@@ -21,7 +21,7 @@ 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";
@@ -72,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. */
@@ -136,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)";
@@ -301,6 +323,8 @@ 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, scripts] = await Promise.all([
         this.likely(job.prompt, controller.signal),
@@ -363,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;
@@ -440,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/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

@@ -60,6 +60,7 @@ const OrchestrateSchema = Type.Object({
   ),
   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/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" })),

package/src/state/work-time.ts

@@ -16,6 +16,8 @@ import { taskDirFor } from "./persistence.ts";
 export interface ActiveRun {
   runId: string;
   parentRunId?: string;
+  /** The worker's domain (`backend`, `designer`), for who is doing what. */
+  domain?: string;
   stepInstruction?: string;
   instruction: string;
   startedAt: string;
@@ -104,7 +106,7 @@ export function taskWork(root: string, configDir: string, taskId: string, now =
 const noted = new Map<string, Set<string>>();
 
 /** A worker run of the task started or ended: the steps it works on read as active while it runs. */
-export function noteWorkerRun(root: string, configDir: string, taskId: string, run: { runId: string; parentRunId?: string; stepInstruction?: string; instruction?: string; startedAt: string; status: string }): void {
+export function noteWorkerRun(root: string, configDir: string, taskId: string, run: { runId: string; parentRunId?: string; stepInstruction?: string; instruction?: string; domain?: string; startedAt: string; status: string }): void {
   const running = run.status === "running";
   const ids = noted.get(taskId) ?? new Set<string>();
   if (running === ids.has(run.runId)) return;
@@ -113,7 +115,7 @@ export function noteWorkerRun(root: string, configDir: string, taskId: string, r
   noted.set(taskId, ids);
   updateWork(root, configDir, taskId, (work) => {
     work.active = work.active.filter((entry) => entry.runId !== run.runId);
-    if (running) work.active.push({ runId: run.runId, instruction: run.instruction ?? "", startedAt: run.startedAt, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), ...(run.stepInstruction ? { stepInstruction: run.stepInstruction } : {}) });
+    if (running) work.active.push({ runId: run.runId, instruction: run.instruction ?? "", startedAt: run.startedAt, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), ...(run.domain ? { domain: run.domain } : {}), ...(run.stepInstruction ? { stepInstruction: run.stepInstruction } : {}) });
   });
 }
 

package/src/webui/api/plan-facts.ts

@@ -30,7 +30,7 @@ function activeRuns(task: Task, work: WorkProjection | undefined): AgentRun[] {
   const finished = new Set((task.workerRuns ?? []).map((record) => record.runId));
   return (work?.active ?? [])
     .filter((run) => !finished.has(run.runId))
-    .map((run) => ({ runId: run.runId, parentRunId: run.parentRunId, stepInstruction: run.stepInstruction, taskId: task.id, domain: "backend" as const, role: "worker" as const, status: "running" as const, instruction: run.instruction, output: "", attempts: 1, startedAt: run.startedAt }));
+    .map((run) => ({ runId: run.runId, parentRunId: run.parentRunId, stepInstruction: run.stepInstruction, taskId: task.id, domain: (run.domain === "designer" || run.domain === "qa" ? run.domain : "backend") as AgentRun["domain"], role: "worker" as const, status: "running" as const, instruction: run.instruction, output: "", attempts: 1, startedAt: run.startedAt }));
 }
 
 /** One step as the lobby shows it: its state, and while a worker is on it, how long they have worked on it. */
@@ -40,10 +40,20 @@ export interface StepView {
   active: boolean;
   activeAgentCount: number;
   runIds: string[];
+  /** The agents on it right now: who, doing what, since when; a child names its parent. */
+  agents: StepAgent[];
   /** Worker time on the step, in ms. */
   workedMs: number;
 }
 
+export interface StepAgent {
+  runId: string;
+  parentRunId?: string;
+  domain: string;
+  instruction: string;
+  startedAt: string;
+}
+
 /**
  * The plan's steps with their state, which ones a worker is on right now and
  * the worker time on each. A step being worked on is never done, so steps run
@@ -54,8 +64,13 @@ export function stepViews(task: Task, work: WorkProjection | undefined, now = Da
   const runs = [...persistedTaskRuns(task), ...activeRuns(task, work)];
   const checklist = planChecklist(task.plan, runs);
   const times = stepWork(planSteps(task.plan), runs, now);
+  const byId = new Map(runs.map((run) => [run.runId, run]));
   return checklist.map((step, index) => {
     const time = times[index] ?? { ms: 0, active: false, activeAgentCount: 0, runIds: [] };
-    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, runIds: time.runIds, workedMs: Math.round(time.ms) };
+    const agents = time.runIds.flatMap((runId) => {
+      const run = byId.get(runId);
+      return run ? [{ runId, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), domain: run.domain, instruction: (run.instruction ?? "").split("\n")[0]!.trim(), startedAt: run.startedAt }] : [];
+    });
+    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, runIds: time.runIds, agents, workedMs: Math.round(time.ms) };
   });
 }

package/src/webui/api/tasks.ts

@@ -311,7 +311,7 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
     steps: stepViews(found, work, now).map((step) => ({
       text: step.text,
       status: step.status === "pending" ? "open" : step.status,
-      ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount } : {}),
+      ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount, agents: step.agents } : {}),
     })),
     amendments: [...found.amendments],
     waiting: waitingOf(found),

package/src/webui/protocol.ts

@@ -420,7 +420,7 @@ export interface TaskDetail {
    * The plan as a checklist, in order; `current` is the step under way, `active` the steps a worker is on right now,
    * each with its worker time (ms, as of the reply).
    */
-  steps: Array<{ text: string; status: "done" | "current" | "open"; active?: boolean; workedMs?: number; activeAgentCount?: number }>;
+  steps: Array<{ text: string; status: "done" | "current" | "open"; active?: boolean; workedMs?: number; activeAgentCount?: number; agents?: StepAgentInfo[] }>;
   /** How long the task's agents have worked on it, idle time left out (ms, as of the reply); `running` while they work. */
   work?: WorkClock;
   amendments: string[];
@@ -676,3 +676,12 @@ export interface Api {
 }
 
 export type ApiName = keyof Api;
+
+/** An agent on a step right now: its domain, what it was told (first line), since when; a child names its parent. */
+export interface StepAgentInfo {
+  runId: string;
+  parentRunId?: string;
+  domain: string;
+  instruction: string;
+  startedAt: string;
+}

package/src/workflow/workflow.ts

@@ -32,7 +32,7 @@ import { mapConcurrent } from "../execution/agent-runner.ts";
 import { parseWorkerResult } from "../roles/worker.ts";
 import { autoNote, DESK_TOOLS, DeskSession } from "../desk/session.ts";
 import type { Handover } from "../desk/desk.ts";
-import { changedFiles, commitBefore, headCommit, readRepositoryDiff } from "../execution/git.ts";
+import { changedFiles, commitBefore, commitFiles, commitMessage, headCommit, readRepositoryDiff, uncommitted } from "../execution/git.ts";
 import { appendChange, explainChanges, provenanceLines, provenanceSummary, readChanges, type FileProvenance } from "../state/changes.ts";
 import { budgetLine, budgetState, formatMinutes, MIN_READ_MS, parseMinutes, qaAllotment, readBudget, readerAllotment, updateBudget, workerAllotment, type Allotment, type BudgetState, type TaskBudget } from "../state/budget.ts";
 import type { AgentTime } from "../execution/agent-runner.ts";
@@ -141,6 +141,8 @@ export interface OrchestrateParams {
   note?: string;
   reason?: string;
   text?: string;
+  /** complete: the commit message for the agents' changes. */
+  message?: string;
   /** track: the path the task takes. */
   track?: "fast" | "full";
   /** track: who takes part (designer, backend, qa, researcher). */
@@ -1570,6 +1572,7 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   // The gate refuses before any side effect, so a refusal leaves the task untouched.
   const oversized = overThreshold(readDataRoots(deps.root, deps.configDir), deps.config.knowledge.compactionThreshold);
   if (oversized.length > 0) throw new Error(`cannot complete: knowledge files over the compaction threshold: ${oversized.map((entry) => `${entry.agent}/${entry.file} (${entry.chars})`).join(", ")}. First record domain-relevant facts where they belong with action=knowledge (domain=designer|backend|qa), then rewrite each oversized file with action=compact, then call complete again.`);
+  const committed = await commitTaskWork(task, params, deps);
   const summary = params.text?.trim() || task.proposal || task.title;
   recordCompletion(deps, task, summary);
   removeTaskScratchpads(deps.root, deps.configDir, task.id);
@@ -1581,7 +1584,43 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   flushDecisions(deps, task);
   const delivery = await offerDelivery(task, deps);
   const left = lint?.state === "failing" ? ` ${task.lintWaiver ? "Accepted by the user with lint errors" : "Lint (advisory)"}: ${lintSummary(lint)} Tell the user.` : "";
-  return `Task ${task.id} completed. History recorded and temporary scratchpads removed. ${delivery}${left}`;
+  return `Task ${task.id} completed.${committed} History recorded and temporary scratchpads removed. ${delivery}${left}`;
+}
+
+/** The files a task's own workers changed: not one that held changes before they started, nor another task's. */
+function agentsWork(files: readonly FileProvenance[]): string[] {
+  return files.filter((file) => file.kinds.includes("planned") && !file.kinds.includes("pre-existing") && !file.kinds.includes("other-task")).map((file) => file.path);
+}
+
+/**
+ * The oracle commits what its agents changed before the task is called done,
+ * with its own short message (`message`); nothing else in the tree is
+ * staged or committed. "" when git is not in use or nothing is left to commit.
+ */
+async function commitTaskWork(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
+  const state = await changeState(deps, task, await reviewBase(task, deps));
+  if (!state) return "";
+  const ours = agentsWork(state.files);
+  const dirty = await uncommitted(state.top, ours).catch(() => []);
+  if (dirty.length === 0) return "";
+  const listed = dirty.slice(0, 20).join(", ") + (dirty.length > 20 ? ` and ${dirty.length - 20} more` : "");
+  if (!params.message?.trim()) throw new Error(`cannot complete: commit the agents' changes first. Call complete again with message: a concise commit message for them (a first line of 72 characters or fewer saying what changed, at most three short lines below it). The engine commits only these files: ${listed}`);
+  let message: string;
+  try {
+    message = commitMessage(params.message);
+  } catch (error) {
+    throw new Error(`cannot complete: ${(error as Error).message}`);
+  }
+  let result: Awaited<ReturnType<typeof commitFiles>>;
+  try {
+    result = await commitFiles(state.top, dirty, message);
+  } catch (error) {
+    throw new Error(`cannot complete: git refused the commit: ${(error as Error).message}`);
+  }
+  if (!result) return "";
+  const others = await uncommitted(state.top, state.files.map((file) => file.path).filter((path) => !ours.includes(path))).catch(() => []);
+  const left = others.length > 0 ? ` Left uncommitted, not this task's agents' work: ${others.slice(0, 10).join(", ")}${others.length > 10 ? ` and ${others.length - 10} more` : ""}.` : "";
+  return ` Committed ${result.files.length} file${result.files.length === 1 ? "" : "s"} as ${result.commit.slice(0, 7)}: "${message.split("\n")[0]}".${left}`;
 }
 
 /** Completion always offers delivery to the user, including in auto mode. */