pi-roundtable-coding 0.27.1 → 0.28.0

package/src/coding-desk.ts

@@ -1,10 +1,13 @@
-import type {
-	ChannelKey,
-	HeldCall,
-	InterimTextMode,
-	Logger,
-	OwnerPrompts,
-	ThinkingLevel,
+import {
+	type ChannelKey,
+	type ConversationModes,
+	type HeldCall,
+	type InterimTextMode,
+	type Logger,
+	type OwnerPrompts,
+	SYSTEM_PRINCIPAL,
+	type ThinkingLevel,
+	type Tier,
 } from "pi-roundtable";
 import {
 	AgentError,
@@ -13,13 +16,32 @@ import {
 	type DispatchThread,
 	type DispatchThreads,
 	InterimPoster,
+	type PromptSlot,
 	promptSlot,
 	workTimeout,
+	YOLO_CARDED_SHELL_CLASSES,
 } from "pi-roundtable/kit";
-import type { RepoShelf, RepoState } from "./repo-shelf.ts";
+import type {
+	Integration,
+	RepoShelf,
+	RepoState,
+	WorkerTree,
+} from "./repo-shelf.ts";
 import { CodingWorkerFailure } from "./worker-failure.ts";
 
 export type HeldCallAnswer = "approved" | "declined" | "held";
+/** Who spoke the turn that started a job, as yolo and long-running modes need to know. */
+export interface CodingSpeaker {
+	id: string;
+	principalId: string;
+	name?: string;
+	tier?: Tier;
+}
+/** The conversation whose turn started a job, whose modes the worker follows live. */
+export interface CodingStarter {
+	channel: ChannelKey;
+	speaker: CodingSpeaker;
+}
 export interface CodingJob {
 	id: number;
 	repo: string;
@@ -27,6 +49,8 @@ export interface CodingJob {
 	channel: ChannelKey;
 	/** The calling turn's channel, where a progress thread opens. */
 	origin?: ChannelKey;
+	/** The conversation that started it; its yolo and long-running modes apply while it works. */
+	starter?: CodingStarter;
 	/** Host-resolved names of the skills carried to this run. */
 	skillNames?: string[];
 	/** Progress thread, when the surface supports one. */
@@ -34,9 +58,19 @@ export interface CodingJob {
 	model: string;
 	thinking: ThinkingLevel;
 	skillFiles: string[];
+	/** When it was asked for; a queued job starts later. */
+	queuedAt?: Date;
+	/** When its worker started. */
 	startedAt: Date;
 	startHead: string;
+	/** The worker's own branch, in its own worktree, once it has started. */
+	branch?: string;
 }
+/** A started or queued job, as `CodingDesk.start` answers. */
+export type CodingStart = CodingJob & {
+	/** Its place in the queue, from 1, when every worker slot is taken; absent when it started. */
+	queuePosition?: number;
+};
 /** What the worker writes and runs as it goes, for its thread's progress posts. */
 export interface CodingProgress {
 	/** A finished message of the worker's session: its role, stop reason, and text. */
@@ -61,8 +95,24 @@ export interface CodingResult {
 	job: CodingJob;
 	outcome: { ok: true; report: string } | { ok: false; error: string };
 	held: string[];
+	/** Held calls the starter's yolo mode approved without a card. */
+	autoApproved?: string[];
 	state?: RepoState;
 	commits: string[];
+	/** How the worker's branch came back into the clone; absent when no worktree was made. */
+	integration?: Integration;
+}
+/** The conversations' modes, read live for each held call and at each work-time limit. */
+export type CodingModes = Pick<ConversationModes, "peek"> &
+	Partial<Pick<ConversationModes, "autoApproved">>;
+/**
+ * The host's autonomy limits, as its `autonomy` config resolves them: what yolo may approve, and
+ * how long a long-running run works in all.
+ */
+export interface CodingAutonomy {
+	yolo?: { allow?: readonly string[]; card?: readonly string[] };
+	/** Default four hours; at most 2147483647. */
+	longRunningMaxMs?: number;
 }
 export interface CodingThreadText {
 	initial?(job: CodingJob): string;
@@ -71,7 +121,15 @@ export interface CodingThreadText {
 	report?(result: CodingResult): string;
 }
 export interface CodingDeskOptions {
-	shelf: Pick<RepoShelf, "dirOf" | "state" | "commitsSince">;
+	shelf: Pick<
+		RepoShelf,
+		| "dirOf"
+		| "state"
+		| "addWorktree"
+		| "integrate"
+		| "treeState"
+		| "treeCommits"
+	>;
 	worker: CodingWorker;
 	prompts?(channel: ChannelKey): OwnerPrompts | undefined;
 	/** When configured, approval cards stay in the job's thread; no thread means held. */
@@ -88,6 +146,17 @@ export interface CodingDeskOptions {
 	interimText?: InterimTextMode;
 	/** Length from which an intermediate text is posted as its own message; default 400. */
 	interimPrimaryChars?: number;
+	/** Workers running at once on the host, across repositories and channels; default 4. */
+	maxWorkers?: number;
+	/** Tasks waiting for a worker slot, first in first out; one more is refused. Default 16. */
+	maxQueued?: number;
+	/**
+	 * The conversations' modes: with them a worker follows the yolo and long-running modes of the
+	 * conversation that started it, read live, when an owner other than the host spoke that turn.
+	 */
+	modes?: CodingModes;
+	/** The host's autonomy limits for those modes; pass the same values its `autonomy` config sets. */
+	autonomy?: CodingAutonomy;
 }
 /** What a coding report keeps of a long run; each is a count of characters or entries, or `Infinity` for no bound. */
 export interface CodingLimits {
@@ -119,51 +188,149 @@ function bounded(text: string, max: number): string {
 		: text;
 }
 
-/** One worker per repository, at most three per channel; results and jobs are in memory. */
+const DEFAULT_TIMEOUT_MS = 3_600_000;
+/** The core's default long-running ceiling, four hours. */
+const DEFAULT_LONG_RUNNING_MS = 4 * 60 * 60_000;
+/** How often a run past its own limit looks again at the starter's long-running mode. */
+const LONG_RUNNING_STEP_MS = 60_000;
+const MAX_TIMER_MS = 2_147_483_647;
+const DEFAULT_MAX_WORKERS = 4;
+const DEFAULT_MAX_QUEUED = 16;
+
+function checkTime(name: string, value: number): void {
+	if (!Number.isFinite(value) || value <= 0 || value > MAX_TIMER_MS)
+		throw new AgentError(
+			`${name} must be positive, finite and at most ${MAX_TIMER_MS}.`,
+		);
+}
+function checkCount(name: string, value: number, least: number): void {
+	if (!Number.isSafeInteger(value) || value < least)
+		throw new AgentError(
+			`${name} must be a whole number of at least ${least}; got ${value}.`,
+		);
+}
+
+/** The rule a class belongs to: the part before its first dot, or a rule's bare name. */
+function ruleOf(id: string): string {
+	const dot = id.indexOf(".");
+	return dot === -1 ? id : id.slice(0, dot);
+}
+
+interface Running {
+	job: CodingJob;
+	controller: AbortController;
+	done?: Promise<void>;
+}
+
+/**
+ * Up to `maxWorkers` workers at once, each in its own worktree; more tasks wait in a FIFO queue.
+ * A finished worker's branch is rebased onto its clone and fast-forwarded, one clone at a time.
+ * Results and jobs are in memory.
+ */
 export class CodingDesk {
 	readonly #options: CodingDeskOptions;
+	readonly #maxWorkers: number;
+	readonly #maxQueued: number;
+	readonly #longRunningMs: number;
+	readonly #yoloApproves: (id: string) => boolean;
 	/** Every run until its report is delivered, for idle(). */
 	readonly #pending = new Set<Promise<void>>();
-	readonly #running = new Map<
-		number,
-		{ job: CodingJob; controller: AbortController; done?: Promise<void> }
-	>();
+	readonly #running = new Map<number, Running>();
+	readonly #queue: CodingJob[] = [];
+	/** The last integration asked for in each repository, which the next waits for. */
+	readonly #integrations = new Map<string, Promise<unknown>>();
+	/** Repositories whose clone an integration is changing now. */
+	readonly #integrating = new Set<string>();
+	/** Reports and pushes in progress, by repository. */
+	readonly #shipping = new Map<string, Promise<unknown>>();
 	#nextId = 1;
 	#stopped = false;
 	constructor(options: CodingDeskOptions) {
-		if (
-			!Number.isFinite(options.timeoutMs ?? 3_600_000) ||
-			(options.timeoutMs ?? 3_600_000) <= 0 ||
-			(options.timeoutMs ?? 3_600_000) > 2_147_483_647
-		)
-			throw new AgentError(
-				"timeoutMs must be positive, finite and at most 2147483647.",
-			);
+		checkTime("timeoutMs", options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+		const longRunning =
+			options.autonomy?.longRunningMaxMs ?? DEFAULT_LONG_RUNNING_MS;
+		checkTime("autonomy.longRunningMaxMs", longRunning);
+		this.#maxWorkers = options.maxWorkers ?? DEFAULT_MAX_WORKERS;
+		this.#maxQueued = options.maxQueued ?? DEFAULT_MAX_QUEUED;
+		checkCount("maxWorkers", this.#maxWorkers, 1);
+		checkCount("maxQueued", this.#maxQueued, 0);
+		this.#longRunningMs = longRunning;
+		const allow = new Set(options.autonomy?.yolo?.allow ?? []);
+		const card = new Set(options.autonomy?.yolo?.card ?? []);
+		const carded = new Set<string>(YOLO_CARDED_SHELL_CLASSES);
+		// The core's yolo rules: a carded class or rule never, an unclassed call only by its rule's name.
+		this.#yoloApproves = (id) => {
+			if (card.has(id) || card.has(ruleOf(id))) return false;
+			if (!id.includes(".")) return allow.has(id);
+			return !carded.has(id) || allow.has(id);
+		};
 		this.#options = options;
 	}
+	/** The channels of running workers, which a shutdown waits for; queued tasks are not among them. */
 	runningChannels(): ChannelKey[] {
 		return [...this.#running.values()].map(({ job }) => job.channel);
 	}
+	/** The channels of queued tasks, in queue order. */
+	queuedChannels(): ChannelKey[] {
+		return this.#queue.map((job) => job.channel);
+	}
 	busy(): string[] {
-		return [...this.#running.values()].map(
-			({ job }) => `Coding #${job.id} in ${job.repo}`,
-		);
+		return [
+			...[...this.#running.values()].map(
+				({ job }) => `Coding #${job.id} in ${job.repo}`,
+			),
+			...this.#queue.map(
+				(job, index) =>
+					`Coding #${job.id} in ${job.repo}, queued (position ${index + 1})`,
+			),
+		];
 	}
+	/** Refuses while a worker's branch is being merged into the clone; running workers do not count. */
 	checkIdle(repo: string): void {
-		if ([...this.#running.values()].some(({ job }) => job.repo === repo))
-			throw new AgentError(`A coding worker is still using ${repo}.`);
+		if (this.#integrating.has(repo))
+			throw new AgentError(
+				`A coding worker's commits are being merged into ${repo}; try again in a moment.`,
+			);
+	}
+	/** Whether a report or push is in progress for the repository. */
+	shipping(repo: string): boolean {
+		return this.#shipping.has(repo);
+	}
+	/**
+	 * Runs a report or push of the repository, one at a time; refuses during an integration, and
+	 * an integration that comes due waits for it.
+	 */
+	async ship<T>(repo: string, operation: () => Promise<T>): Promise<T> {
+		this.checkIdle(repo);
+		if (this.#shipping.has(repo))
+			throw new AgentError(
+				"A report or push is already in progress for this repository.",
+			);
+		const done = operation();
+		this.#shipping.set(
+			repo,
+			done.catch(() => {}),
+		);
+		try {
+			return await done;
+		} finally {
+			this.#shipping.delete(repo);
+		}
 	}
 	async idle(): Promise<void> {
-		await Promise.all(this.#pending);
+		// A run that ends starts the next queued one before it settles, so look again.
+		while (this.#pending.size) await Promise.all(this.#pending);
 	}
+	/** Stops the running workers and drops the queued tasks, telling each that it never ran. */
 	async stop(): Promise<void> {
 		this.#stopped = true;
+		for (const job of this.#queue.splice(0)) this.#track(this.#drop(job));
 		for (const run of this.#running.values()) run.controller.abort();
 		await this.idle();
 	}
 	async start(
 		request: Omit<CodingJob, "id" | "startedAt" | "startHead" | "thread">,
-	): Promise<CodingJob> {
+	): Promise<CodingStart> {
 		if (this.#stopped) throw new AgentError("The coding desk is stopped.");
 		const task = request.task.trim();
 		if (!task) throw new AgentError("The task is required.");
@@ -171,75 +338,186 @@ export class CodingDesk {
 			throw new AgentError(
 				`The task is ${task.length} characters; keep it within ${MAX_CODING_TASK_CHARS}.`,
 			);
-		const dir = this.#options.shelf.dirOf(request.repo);
-		const busy = [...this.#running.values()].find(
-			({ job }) => job.repo === request.repo,
-		);
-		if (busy)
-			throw new AgentError(
-				`Coding task #${busy.job.id} is still working in ${request.repo}; one worker runs per repository.`,
-			);
-		const inChannel = [...this.#running.values()].filter(
-			({ job }) => job.channel === request.channel,
-		).length;
-		if (inChannel >= 3)
+		this.#options.shelf.dirOf(request.repo);
+		const full = this.#running.size >= this.#maxWorkers;
+		if (full && this.#queue.length >= this.#maxQueued)
 			throw new AgentError(
-				`This channel already has ${inChannel} coding workers running; wait for one to report back.`,
+				`All ${this.#maxWorkers} coding workers are busy and ${this.#queue.length} tasks are already waiting; try again after one reports back.`,
 			);
+		const now = new Date();
 		const job: CodingJob = {
 			...request,
 			task,
 			id: this.#nextId++,
-			startedAt: new Date(),
+			queuedAt: now,
+			startedAt: now,
 			startHead: "",
 		};
-		const run = {
-			job,
-			controller: new AbortController(),
-			done: undefined as Promise<void> | undefined,
-		};
-		this.#running.set(job.id, run);
 		// Reserve before the first await, including startup state reads.
-		run.done = this.#run(job, dir, run.controller)
+		if (!full) {
+			this.#launch(job);
+			return job;
+		}
+		this.#queue.push(job);
+		return { ...job, queuePosition: this.#queue.length };
+	}
+	#track(done: Promise<void>): void {
+		this.#pending.add(done);
+		void done.finally(() => this.#pending.delete(done));
+	}
+	#launch(job: CodingJob): void {
+		job.startedAt = new Date();
+		const run: Running = { job, controller: new AbortController() };
+		this.#running.set(job.id, run);
+		run.done = this.#run(job, run.controller)
 			.catch(() => {
 				this.#options.logger.error(
 					{ job: job.id },
 					"Coding report delivery failed.",
 				);
 			})
-			.finally(() => this.#running.delete(job.id));
-		const done = run.done;
-		this.#pending.add(done);
-		void done.finally(() => this.#pending.delete(done));
-		return job;
+			.finally(() => this.#free(job));
+		this.#track(run.done);
+	}
+	/** Frees the job's slot and starts the next queued tasks. */
+	#free(job: CodingJob): void {
+		this.#running.delete(job.id);
+		while (
+			!this.#stopped &&
+			this.#running.size < this.#maxWorkers &&
+			this.#queue.length
+		) {
+			const next = this.#queue.shift();
+			if (next) this.#launch(next);
+		}
+	}
+	async #drop(job: CodingJob): Promise<void> {
+		try {
+			await this.#options.deliver({
+				job,
+				outcome: {
+					ok: false,
+					error:
+						"the host stopped before this queued task started; nothing ran, so start it again",
+				},
+				held: [],
+				commits: [],
+			});
+		} catch {
+			this.#options.logger.error(
+				{ job: job.id },
+				"Coding report delivery failed.",
+			);
+		}
+	}
+	/** Whether the starter's modes may act: only for an owner other than the host's own principal. */
+	#modeOf(job: CodingJob): { yolo: boolean; longRunning: boolean } {
+		const { modes } = this.#options;
+		const speaker = job.starter?.speaker;
+		if (
+			!modes ||
+			!job.starter ||
+			speaker?.tier !== "owner" ||
+			speaker.principalId === SYSTEM_PRINCIPAL
+		)
+			return { yolo: false, longRunning: false };
+		const mode = modes.peek(job.starter.channel);
+		return { yolo: mode.yolo === true, longRunning: mode.longRunning === true };
+	}
+	/** Whether the starter's yolo mode approves the call now, as it would in that conversation. */
+	#yolo(job: CodingJob, call: HeldCall): boolean {
+		if (!this.#modeOf(job).yolo || call.approverIds !== undefined) return false;
+		const classes = call.holdClasses;
+		if (!classes?.length || !classes.every(this.#yoloApproves)) return false;
+		const { starter } = job;
+		if (!starter) return false;
+		try {
+			this.#options.modes?.autoApproved?.({
+				channel: starter.channel,
+				tool: call.tool,
+				action: `coding #${job.id} in ${job.repo}: ${call.action}`,
+				classes: [...classes],
+				principalId: starter.speaker.principalId,
+				at: new Date(),
+			});
+		} catch {
+			this.#options.logger.warn(
+				{ job: job.id },
+				"Recording a yolo approval failed.",
+			);
+		}
+		return true;
 	}
-	async #run(
+	/**
+	 * The worker's work-time budget: `timeoutMs`, then, while the starter's long-running mode is
+	 * on, further steps up to `autonomy.longRunningMaxMs` in all. Card waits never count.
+	 */
+	#budget(
 		job: CodingJob,
-		dir: string,
-		controller: AbortController,
-	): Promise<void> {
-		const {
-			shelf,
-			worker,
-			prompts,
-			threads,
-			threadText,
-			deliver,
-			timeoutMs = 3_600_000,
-		} = this.#options;
+		slot: PromptSlot,
+		expire: (workedMs: number) => void,
+	): () => void {
+		const base = this.#options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		let worked = 0;
+		let cancel = () => {};
+		const phase = (ms: number) => {
+			cancel = workTimeout(ms, slot, () => {
+				worked += ms;
+				if (this.#modeOf(job).longRunning && worked < this.#longRunningMs)
+					phase(Math.min(LONG_RUNNING_STEP_MS, this.#longRunningMs - worked));
+				else expire(worked);
+			});
+		};
+		phase(base);
+		return () => cancel();
+	}
+	/** Integrations of one clone run one after another, and never during its report or push. */
+	async #integrate(tree: WorkerTree): Promise<Integration> {
+		const { repo } = tree;
+		const previous = this.#integrations.get(repo) ?? Promise.resolve();
+		const mine = previous
+			.catch(() => {})
+			.then(async () => {
+				for (let ship = this.#shipping.get(repo); ship; ) {
+					await ship;
+					ship = this.#shipping.get(repo);
+				}
+				this.#integrating.add(repo);
+				try {
+					return await this.#options.shelf.integrate(tree);
+				} finally {
+					this.#integrating.delete(repo);
+				}
+			});
+		this.#integrations.set(repo, mine);
+		try {
+			return await mine;
+		} finally {
+			if (this.#integrations.get(repo) === mine)
+				this.#integrations.delete(repo);
+		}
+	}
+	async #run(job: CodingJob, controller: AbortController): Promise<void> {
+		const { shelf, worker, prompts, threads, threadText, deliver } =
+			this.#options;
 		const slot = promptSlot();
 		const held: string[] = [];
+		const autoApproved: string[] = [];
 		let omittedHeld = 0;
+		let omittedApproved = 0;
 		const maxReport = this.#options.limits?.reportChars ?? MAX_REPORT_CHARS;
 		const maxHeldEntries =
 			this.#options.limits?.heldEntries ?? MAX_HELD_ENTRIES;
 		const maxHeldChars = this.#options.limits?.heldChars ?? MAX_HELD_CHARS;
 		let cancel = () => {};
 		let interim: InterimPoster | undefined;
-		let timedOut = false;
+		let timedOut: number | undefined;
+		let tree: WorkerTree | undefined;
 		let outcome: CodingResult["outcome"];
 		try {
-			job.startHead = (await shelf.state(job.repo)).head;
+			tree = await shelf.addWorktree(job.repo, job.id);
+			job.startHead = tree.base.slice(0, 12);
+			job.branch = tree.branch;
 			if (controller.signal.aborted)
 				throw new AgentError("the worker was stopped");
 			if (threads) {
@@ -276,11 +554,23 @@ export class CodingDesk {
 				`Coding worker #${job.id}`,
 				poster ? () => poster.flush() : undefined,
 			);
-			cancel = workTimeout(timeoutMs, slot, () => {
-				timedOut = true;
+			cancel = this.#budget(job, slot, (worked) => {
+				timedOut = worked;
 				controller.abort();
 			});
 			const review = async (call: HeldCall): Promise<HeldCallAnswer> => {
+				// The starter's yolo mode answers for a call it may approve, read at the time of the call.
+				if (!controller.signal.aborted && this.#yolo(job, call)) {
+					if (autoApproved.length < maxHeldEntries)
+						autoApproved.push(
+							bounded(
+								`${call.action}: ${call.tool} ${call.input}`,
+								maxHeldChars,
+							),
+						);
+					else omittedApproved++;
+					return "approved";
+				}
 				let answer: HeldCallAnswer = "held";
 				try {
 					const decision = await slot.prompts?.confirm(
@@ -318,7 +608,7 @@ export class CodingDesk {
 				return answer;
 			};
 			const report = await worker.run(
-				{ ...job, dir },
+				{ ...job, dir: tree.dir },
 				controller.signal,
 				review,
 				interim,
@@ -338,8 +628,8 @@ export class CodingDesk {
 				);
 			}
 			if (controller.signal.aborted) message = "the worker was stopped";
-			if (timedOut)
-				message = `the worker ran out of time (${Math.round(timeoutMs / 60_000)} minutes)`;
+			if (timedOut !== undefined)
+				message = `the worker ran out of time (${Math.round(timedOut / 60_000)} minutes)`;
 			outcome = { ok: false, error: message };
 		} finally {
 			cancel();
@@ -347,12 +637,36 @@ export class CodingDesk {
 			// What the worker wrote lands before its report.
 			await interim?.flush();
 		}
+		let integration: Integration | undefined;
+		if (tree)
+			try {
+				integration = await this.#integrate(tree);
+			} catch (error) {
+				integration = {
+					status: "refused",
+					branch: tree.branch,
+					dir: tree.dir,
+					reason:
+						error instanceof AgentError
+							? error.message
+							: "the merge failed; inspect the clone and the worktree on the host",
+				};
+			}
 		let state: RepoState | undefined;
 		let commits: string[] = [];
 		try {
-			state = await shelf.state(job.repo);
-			if (job.startHead)
-				commits = await shelf.commitsSince(job.repo, job.startHead);
+			if (
+				tree &&
+				(integration?.status === "conflict" ||
+					integration?.status === "refused")
+			) {
+				// The work stays on its branch: describe the worktree.
+				state = await shelf.treeState(tree);
+				commits = await shelf.treeCommits(tree);
+			} else {
+				state = await shelf.state(job.repo);
+				if (integration?.status === "merged") commits = integration.commits;
+			}
 		} catch {
 			this.#options.logger.warn(
 				{ job: job.id },
@@ -361,12 +675,16 @@ export class CodingDesk {
 		}
 		if (omittedHeld)
 			held.push(`[${omittedHeld} more unapproved actions omitted]`);
+		if (omittedApproved)
+			autoApproved.push(`[${omittedApproved} more approved actions omitted]`);
 		const result: CodingResult = {
 			job,
 			outcome,
 			held,
+			...(autoApproved.length ? { autoApproved } : {}),
 			...(state ? { state } : {}),
 			commits,
+			...(integration ? { integration } : {}),
 		};
 		try {
 			await job.thread?.close(
@@ -379,24 +697,51 @@ export class CodingDesk {
 		} catch {
 			this.#options.logger.warn({ job: job.id }, "Coding thread close failed.");
 		}
-		// The work is over: free the repository before the report turn, so that turn can ship it.
-		this.#running.delete(job.id);
+		// The work is over: free the slot and the repository before the report turn, so that turn can ship it.
+		this.#free(job);
 		await deliver(result);
 	}
 }
 
+/** What became of the worker's branch, for the report. */
+export function integrationText(
+	integration: Integration | undefined,
+	branch: string | undefined,
+): string | undefined {
+	switch (integration?.status) {
+		case "merged":
+			return `Merged ${integration.branch}: rebased onto the clone's branch and fast-forwarded it.`;
+		case "nothing":
+			return `${branch ?? "The worker's branch"} added no commits; its worktree is removed.`;
+		case "conflict":
+			return `Rebasing ${integration.branch} onto the clone's branch conflicted in:\n${integration.files.join("\n") || "(files not listed)"}\nThe rebase was aborted and the clone is unchanged; the branch ${integration.branch} and its worktree ${integration.dir} are kept to resolve.`;
+		case "refused":
+			return `Not merged: ${integration.reason}\nThe branch ${integration.branch} and its worktree ${integration.dir} are kept.`;
+		default:
+			return undefined;
+	}
+}
+
 export function codingReport(result: CodingResult, started: string): string {
-	const { job, outcome, state, commits, held } = result;
+	const { job, outcome, state, commits, held, autoApproved, integration } =
+		result;
+	const merge = integrationText(integration, job.branch);
 	return [
 		`## Coding task #${job.id}: ${job.repo}`,
 		`Started: ${started}`,
 		outcome.ok ? outcome.report : outcome.error,
 		"### Held",
 		held.length ? held.join("\n") : "None.",
+		...(autoApproved?.length
+			? ["### Approved by yolo mode", autoApproved.join("\n")]
+			: []),
 		"### Repository",
-		state
-			? `Branch ${state.branch}, HEAD ${state.head} (was ${job.startHead}).\nNew commits:\n${commits.join("\n") || "None."}\nUncommitted:\n${state.uncommitted.join("\n") || "None."}`
-			: "Unreadable.",
+		[
+			...(merge ? [merge] : []),
+			state
+				? `Branch ${state.branch}, HEAD ${state.head} (was ${job.startHead}).\nNew commits:\n${commits.join("\n") || "None."}\nUncommitted:\n${state.uncommitted.join("\n") || "None."}`
+				: "Unreadable.",
+		].join("\n"),
 		"Review the changes and checks, then use repo_change_report before repo_push.",
 	].join("\n\n");
 }