@possumtech/rummy 0.5.0 → 2.0.1

package/src/agent/AgentLoop.js

@@ -1,26 +1,51 @@
-import { advanceRecovery } from "../plugins/budget/recovery.js";
+import { computeBudget } from "./budget.js";
 import msg from "./messages.js";
-import ResponseHealer from "./ResponseHealer.js";
+
+const HTTP_TO_RUN_STATE = {
+	100: "proposed",
+	102: "streaming",
+	200: "resolved",
+	202: "streaming",
+	499: "cancelled",
+	500: "failed",
+};
 
 export default class AgentLoop {
 	#db;
 	#llmProvider;
 	#hooks;
 	#turnExecutor;
-	#knownStore;
+	#entries;
 	#activeRuns = new Map();
 
-	constructor(db, llmProvider, hooks, turnExecutor, knownStore) {
+	constructor(db, llmProvider, hooks, turnExecutor, entries) {
 		this.#db = db;
 		this.#llmProvider = llmProvider;
 		this.#hooks = hooks;
 		this.#turnExecutor = turnExecutor;
-		this.#knownStore = knownStore;
+		this.#entries = entries;
 	}
 
 	abort(runId) {
-		const controller = this.#activeRuns.get(runId);
-		if (controller) controller.abort();
+		const active = this.#activeRuns.get(runId);
+		if (active) active.controller.abort();
+	}
+
+	/**
+	 * Abort every in-flight run and wait for each drain to settle.
+	 * Called from server close / client teardown so the process can
+	 * exit cleanly instead of leaving detached kickoff Promises
+	 * pinning the event loop.
+	 */
+	async abortAll() {
+		const promises = [];
+		for (const { controller, promise } of this.#activeRuns.values()) {
+			controller.abort();
+			promises.push(promise);
+		}
+		// allSettled: drain waits for every run to finish; rejections are
+		// already surfaced to whoever awaited the original run() call.
+		await Promise.allSettled(promises);
 	}
 
 	async #generateAlias(modelAlias) {
@@ -31,9 +56,126 @@ export default class AgentLoop {
 		return `Turn ${turn}/${maxTurns}`;
 	}
 
-	async #ensureRun(projectId, model, run, options) {
-		const _noRepo = options?.noRepo === true;
-		const isFork = options?.fork === true;
+	async #setRunStatus(runId, alias, httpStatus) {
+		await this.#db.update_run_status.run({ id: runId, status: httpStatus });
+		const state = HTTP_TO_RUN_STATE[httpStatus];
+		if (!state) return;
+		await this.#entries.set({
+			runId,
+			path: `run://${alias}`,
+			state,
+			writer: "system",
+		});
+	}
+
+	async #emitRunState({
+		projectId,
+		runId,
+		alias,
+		turn,
+		status,
+		contextSize,
+		result = null,
+	}) {
+		if (!contextSize) throw new Error("#emitRunState: contextSize is required");
+		const runUsage = await this.#db.get_run_usage.get({ run_id: runId });
+		const history = await this.#entries.getLog(runId);
+		const unknowns = await this.#entries.getUnknowns(runId);
+		const latestSummary = this.#hooks.instructions.findLatestSummary(history);
+
+		// Always emit complete telemetry. When we don't have a fresh turn
+		// result (abort/max-turns/crash), read the last turn's context
+		// tokens from the DB instead. Both code paths compute a real
+		// budget from real data — never undefined, never invented.
+		const rows = await this.#db.get_turn_context.all({
+			run_id: runId,
+			turn,
+		});
+		let totalTokens;
+		if (result) {
+			totalTokens = result.assembledTokens;
+		} else {
+			// No fresh turn result — this happens on abort/max-turns/crash
+			// emits that fire before any turn executed, or after a turn
+			// that never produced tokens. Read the last turn's assembled
+			// context_tokens from the DB; absent means no turn ran yet
+			// (zero is the truth, not a fallback).
+			const lastCtx = await this.#db.get_last_context_tokens.get({
+				run_id: runId,
+			});
+			totalTokens = lastCtx ? lastCtx.context_tokens : 0;
+		}
+		const budget = computeBudget({ rows, contextSize, totalTokens });
+
+		await this.#hooks.run.state.emit({
+			projectId,
+			run: alias,
+			turn,
+			status,
+			summary: latestSummary?.body,
+			history,
+			unknowns: unknowns.map((u) => ({ path: u.path, body: u.body })),
+			telemetry: {
+				modelAlias: result?.modelAlias,
+				model: result?.model,
+				temperature: result?.temperature,
+				context_size: contextSize,
+				context_tokens: totalTokens,
+				ceiling: budget.ceiling,
+				token_usage: budget.tokenUsage,
+				tokens_free: budget.tokensFree,
+				prompt_tokens: runUsage.prompt_tokens,
+				cached_tokens: runUsage.cached_tokens,
+				completion_tokens: runUsage.completion_tokens,
+				reasoning_tokens: runUsage.reasoning_tokens,
+				total_tokens: runUsage.total_tokens,
+				cost: runUsage.cost,
+				context_distribution: await this.#db.get_turn_distribution.all({
+					run_id: runId,
+					turn,
+				}),
+			},
+		});
+	}
+
+	async #writeRunEntry(
+		runId,
+		alias,
+		prompt,
+		{
+			projectId,
+			parentRunId,
+			model,
+			persona = null,
+			temperature = null,
+			contextLimit = null,
+		},
+	) {
+		await this.#entries.set({
+			runId,
+			turn: 0,
+			path: `run://${alias}`,
+			body: prompt ? prompt : "",
+			state: "proposed",
+			attributes: {
+				projectId,
+				parentRunId,
+				model,
+				persona,
+				temperature,
+				contextLimit,
+			},
+			writer: "system",
+		});
+	}
+
+	async ensureRun(projectId, model, run, prompt, options = {}) {
+		const {
+			fork: isFork = false,
+			temperature = null,
+			persona = null,
+			contextLimit = null,
+		} = options;
 		const requestedModel = model;
 
 		if (run && isFork) {
@@ -46,13 +188,18 @@ export default class AgentLoop {
 				parent_run_id: existingRun.id,
 				model: requestedModel,
 				alias,
-				temperature: options?.temperature ?? null,
-				persona: options?.persona ?? null,
-				context_limit: options?.contextLimit ?? null,
+				temperature,
+				persona,
+				context_limit: contextLimit,
 			});
-			await this.#db.fork_known_entries.run({
-				new_run_id: runRow.id,
-				parent_run_id: existingRun.id,
+			await this.#entries.forkEntries(existingRun.id, runRow.id);
+			await this.#writeRunEntry(runRow.id, alias, prompt, {
+				projectId,
+				parentRunId: existingRun.id,
+				model: requestedModel,
+				persona,
+				temperature,
+				contextLimit,
 			});
 			await this.#hooks.run.created.emit({
 				runId: runRow.id,
@@ -64,34 +211,43 @@ export default class AgentLoop {
 
 		if (run) {
 			const existingRun = await this.#db.get_run_by_alias.get({ alias: run });
-			if (!existingRun)
-				throw new Error(msg("error.run_not_found", { runId: run }));
-
-			const existing = this.#activeRuns.get(existingRun.id);
-			if (existing) existing.abort();
-
-			// Clean up stale proposals from interrupted runs
-			const unresolved = await this.#knownStore.getUnresolved(existingRun.id);
-			for (const u of unresolved) {
-				await this.#knownStore.resolve(
-					existingRun.id,
-					u.path,
-					499,
-					"Stale proposal from interrupted run",
-				);
+			if (existingRun) {
+				const existing = this.#activeRuns.get(existingRun.id);
+				if (existing) existing.controller.abort();
+
+				// Clean up stale proposals from interrupted runs
+				const unresolved = await this.#entries.getUnresolved(existingRun.id);
+				for (const u of unresolved) {
+					await this.#entries.set({
+						runId: existingRun.id,
+						path: u.path,
+						state: "cancelled",
+						body: "Stale proposal from interrupted run",
+						outcome: "interrupted",
+					});
+				}
+				return { runId: existingRun.id, alias: existingRun.alias };
 			}
-			return { runId: existingRun.id, alias: existingRun.alias };
+			// Client-specified alias for a brand-new run — accept it verbatim.
 		}
 
-		const alias = await this.#generateAlias(requestedModel);
+		const alias = run ? run : await this.#generateAlias(requestedModel);
 		const runRow = await this.#db.create_run.get({
 			project_id: projectId,
 			parent_run_id: null,
 			model: requestedModel,
 			alias,
-			temperature: options?.temperature ?? null,
-			persona: options?.persona ?? null,
-			context_limit: options?.contextLimit ?? null,
+			temperature,
+			persona,
+			context_limit: contextLimit,
+		});
+		await this.#writeRunEntry(runRow.id, alias, prompt, {
+			projectId,
+			parentRunId: null,
+			model: requestedModel,
+			persona,
+			temperature,
+			contextLimit,
 		});
 		await this.#hooks.run.created.emit({ runId: runRow.id, alias });
 		return { runId: runRow.id, alias };
@@ -119,13 +275,22 @@ export default class AgentLoop {
 		if (!project)
 			throw new Error(msg("error.project_not_found", { projectId }));
 
-		const noRepo = options?.noRepo === true;
-		const noInteraction = options?.noInteraction === true;
-		const noWeb = options?.noWeb === true;
-		const noProposals = options?.noProposals === true;
+		const noRepo = options?.noRepo ?? process.env.RUMMY_NO_REPO === "1";
+		const noInteraction =
+			options?.noInteraction ?? process.env.RUMMY_NO_INTERACTION === "1";
+		const noWeb = options?.noWeb ?? process.env.RUMMY_NO_WEB === "1";
+		const noProposals =
+			options?.noProposals ?? process.env.RUMMY_NO_PROPOSALS === "1";
+		const yolo = options?.yolo ?? process.env.RUMMY_YOLO === "1";
 		const requestedModel = model;
 
-		const runInfo = await this.#ensureRun(projectId, model, run, options);
+		const runInfo = await this.ensureRun(
+			projectId,
+			model,
+			run,
+			prompt,
+			options,
+		);
 		const { runId: currentRunId, alias: currentAlias } = runInfo;
 
 		const loopSeq = await this.#db.next_loop.get({ run_id: currentRunId });
@@ -134,12 +299,13 @@ export default class AgentLoop {
 			sequence: loopSeq.sequence,
 			mode,
 			model: requestedModel,
-			prompt: prompt || "",
+			prompt: prompt ? prompt : "",
 			config: JSON.stringify({
 				noRepo,
 				noInteraction,
 				noWeb,
 				noProposals,
+				yolo,
 				temperature: options?.temperature,
 			}),
 		});
@@ -148,28 +314,53 @@ export default class AgentLoop {
 			return { run: currentAlias, status: 100 };
 		}
 
-		return this.#drainQueue(
+		// Allocate the controller + Promise pair here so `abortAll` can
+		// reach both — abort the controller, await the Promise's drain.
+		const controller = new AbortController();
+		const promise = this.#drainQueue(
 			currentRunId,
 			currentAlias,
 			projectId,
 			project,
 			options,
+			controller,
 		);
+		this.#activeRuns.set(currentRunId, { controller, promise });
+		return promise;
 	}
 
-	async #drainQueue(currentRunId, currentAlias, projectId, project, options) {
-		const controller = new AbortController();
-		this.#activeRuns.set(currentRunId, controller);
+	async #drainQueue(
+		currentRunId,
+		currentAlias,
+		projectId,
+		project,
+		options,
+		controller,
+	) {
+		console.error(`[DRAIN] ${currentAlias} enter (runId=${currentRunId})`);
 
 		try {
 			while (true) {
 				const loop = await this.#db.claim_next_loop.get({
 					run_id: currentRunId,
 				});
-				if (!loop) break;
+				if (!loop) {
+					console.error(`[DRAIN] ${currentAlias} queue empty — exiting`);
+					break;
+				}
+				console.error(
+					`[DRAIN] ${currentAlias} claimed loop id=${loop.id} mode=${loop.mode} seq=${loop.sequence}`,
+				);
 
-				const loopConfig = loop.config ? JSON.parse(loop.config) : {};
+				const loopConfig = JSON.parse(loop.config);
 				const hook = loop.mode === "ask" ? this.#hooks.ask : this.#hooks.act;
+				const {
+					noRepo = false,
+					noInteraction = false,
+					noWeb = false,
+					noProposals = false,
+					yolo = false,
+				} = loopConfig;
 
 				let result;
 				try {
@@ -182,15 +373,19 @@ export default class AgentLoop {
 						currentLoopId: loop.id,
 						requestedModel: loop.model,
 						prompt: loop.prompt,
-						noRepo: loopConfig.noRepo || false,
-						noInteraction: loopConfig.noInteraction || false,
-						noWeb: loopConfig.noWeb || false,
-						noProposals: loopConfig.noProposals || false,
+						noRepo,
+						noInteraction,
+						noWeb,
+						noProposals,
+						yolo,
 						options: { ...options, temperature: loopConfig.temperature },
 						hook,
 						signal: controller.signal,
 					});
 				} catch (err) {
+					console.error(
+						`[DRAIN] ${currentAlias} loop id=${loop.id} threw: ${err.message}`,
+					);
 					await this.#db.complete_loop.run({
 						id: loop.id,
 						status: 500,
@@ -200,6 +395,9 @@ export default class AgentLoop {
 				}
 
 				if (result.status === 413) {
+					console.error(
+						`[DRAIN] ${currentAlias} loop id=${loop.id} overflow=413`,
+					);
 					await this.#db.complete_loop.run({
 						id: loop.id,
 						status: 413,
@@ -212,6 +410,9 @@ export default class AgentLoop {
 					};
 				}
 
+				console.error(
+					`[DRAIN] ${currentAlias} loop id=${loop.id} completed status=${result.status}`,
+				);
 				await this.#db.complete_loop.run({
 					id: loop.id,
 					status: result.status,
@@ -222,7 +423,7 @@ export default class AgentLoop {
 			const runRow = await this.#db.get_run_by_alias.get({
 				alias: currentAlias,
 			});
-			return { run: currentAlias, status: runRow?.status ?? 200 };
+			return { run: currentAlias, status: runRow.status };
 		} finally {
 			this.#activeRuns.delete(currentRunId);
 		}
@@ -241,16 +442,14 @@ export default class AgentLoop {
 		noInteraction,
 		noWeb,
 		noProposals,
+		yolo,
 		options,
 		hook,
 		signal,
 	}) {
 		const runRow = await this.#db.get_run_by_id.get({ id: currentRunId });
 		if (runRow.status !== 102) {
-			await this.#db.update_run_status.run({
-				id: currentRunId,
-				status: 102,
-			});
+			await this.#setRunStatus(currentRunId, currentAlias, 102);
 		}
 
 		const modelContextSize =
@@ -266,20 +465,7 @@ export default class AgentLoop {
 		});
 
 		let loopIteration = 0;
-		const MAX_LOOP_ITERATIONS = Number(process.env.RUMMY_MAX_TURNS) || 15;
-		const healer = new ResponseHealer();
-
-		let _lastAssembledTokens = 0;
-		let recovery = null; // { target, promptPath, strikes, lastTokens }
-
-		// Previous loop entries stay at full fidelity — the model is
-		// instructed to summarize and demote them. Budget enforcement
-		// catches overflow if the model fails to manage context.
-
-		// Restore any prompt entries left at summary fidelity by a recovery
-		// phase that was interrupted (server crash, restart). If the full
-		// prompt would overflow, Prompt Demotion on turn 1 handles it.
-		await this.#knownStore.restoreSummarizedPrompts(currentRunId);
+		const MAX_LOOP_ITERATIONS = Number(process.env.RUMMY_MAX_TURNS);
 
 		await this.#hooks.loop.started.emit({
 			runId: currentRunId,
@@ -291,9 +477,17 @@ export default class AgentLoop {
 		try {
 			while (loopIteration < MAX_LOOP_ITERATIONS) {
 				if (signal.aborted) {
-					await this.#db.update_run_status.run({
-						id: currentRunId,
+					console.error(
+						`[LOOP] ${currentAlias} iter=${loopIteration} ABORT via signal`,
+					);
+					await this.#setRunStatus(currentRunId, currentAlias, 499);
+					await this.#emitRunState({
+						projectId,
+						runId: currentRunId,
+						alias: currentAlias,
+						turn: loopIteration,
 						status: 499,
+						contextSize,
 					});
 					const out = {
 						run: currentAlias,
@@ -304,6 +498,9 @@ export default class AgentLoop {
 					return out;
 				}
 				loopIteration++;
+				console.error(
+					`[LOOP] ${currentAlias} iter=${loopIteration} ENTER (max=${MAX_LOOP_ITERATIONS})`,
+				);
 
 				let turnPrompt;
 				if (loopIteration === 1) {
@@ -315,6 +512,9 @@ export default class AgentLoop {
 					);
 				}
 
+				console.error(
+					`[LOOP] ${currentAlias} iter=${loopIteration} executing turn`,
+				);
 				const result = await this.#turnExecutor.execute({
 					mode,
 					project,
@@ -326,198 +526,123 @@ export default class AgentLoop {
 					loopPrompt: turnPrompt,
 					loopIteration,
 					noRepo,
+					noWeb,
+					noInteraction,
+					noProposals,
+					yolo,
 					toolSet,
-					inRecovery: recovery !== null,
 					contextSize,
 					options: { ...options, isContinuation: loopIteration > 1 },
 					signal,
 				});
+				console.error(
+					`[LOOP] ${currentAlias} iter=${loopIteration} turn done: status=${result.status} turn=${result.turn}`,
+				);
 
-				if (result.status === 413) {
-					await this.#db.complete_loop.run({
-						id: currentLoopId,
-						status: 413,
-						result: null,
-					});
-					await this.#db.update_run_status.run({
-						id: currentRunId,
-						status: 200,
-					});
-					const out = {
-						run: currentAlias,
-						status: 413,
-						overflow: result.overflow,
-						assembledTokens: result.assembledTokens,
-						contextSize: result.contextSize,
-						turn: result.turn,
-					};
-					await hook.completed.emit({ projectId, ...out });
-					return out;
-				}
-
-				_lastAssembledTokens = result.assembledTokens;
-
-				// Budget recovery: enforce progress toward context target.
-				const ra = advanceRecovery(recovery, result);
-				recovery = ra.next;
-				if (ra.action === "restore" && ra.promptPath) {
-					await this.#knownStore.setFidelity(
-						currentRunId,
-						ra.promptPath,
-						"promoted",
-					);
-				}
-				if (ra.action === "hard413") {
-					await this.#db.update_run_status.run({
-						id: currentRunId,
-						status: 413,
-					});
-					const out = {
-						run: currentAlias,
-						status: 413,
-						turn: result.turn,
-					};
-					await hook.completed.emit({ projectId, ...out });
-					return out;
-				}
-
-				const runUsage = await this.#db.get_run_usage.get({
-					run_id: currentRunId,
-				});
-				const history = await this.#knownStore.getLog(currentRunId);
-				const unknowns = await this.#db.get_unknowns.all({
-					run_id: currentRunId,
+				const verdict = await this.#hooks.error.verdict({
+					store: this.#entries,
+					runId: currentRunId,
+					loopId: currentLoopId,
+					turn: result.turn,
+					recorded: result.recorded,
+					summaryText: result.summaryText,
 				});
-				const latestSummary = history
-					.filter((e) => e.status === 200 && e.path?.startsWith("summarize://"))
-					.at(-1);
+				const vStatus = verdict.status === undefined ? "-" : verdict.status;
+				const vReason = verdict.reason ? verdict.reason : "-";
+				console.error(
+					`[LOOP] ${currentAlias} iter=${loopIteration} verdict: continue=${verdict.continue} status=${vStatus} reason=${vReason}`,
+				);
 
-				await this.#hooks.run.state.emit({
+				await this.#emitRunState({
 					projectId,
-					run: currentAlias,
+					runId: currentRunId,
+					alias: currentAlias,
 					turn: result.turn,
-					status: 102,
-					summary: latestSummary?.body || "",
-					history,
-					unknowns: unknowns.map((u) => ({ path: u.path, body: u.body })),
-					telemetry: {
-						modelAlias: result.modelAlias,
-						model: result.model,
-						temperature: result.temperature,
-						context_size: result.contextSize,
-						context_tokens:
-							(
-								await this.#db.get_turn_context_tokens.get({
-									run_id: currentRunId,
-									sequence: result.turn,
-								})
-							)?.context_tokens ?? 0,
-						prompt_tokens: runUsage.prompt_tokens,
-						cached_tokens: runUsage.cached_tokens,
-						completion_tokens: runUsage.completion_tokens,
-						reasoning_tokens: runUsage.reasoning_tokens,
-						total_tokens: runUsage.total_tokens,
-						cost: runUsage.cost,
-						context_distribution: await this.#db.get_turn_distribution.all({
-							run_id: currentRunId,
-							turn: result.turn,
-						}),
-					},
+					status: verdict.continue ? 102 : verdict.status,
+					contextSize,
+					result,
 				});
 				await this.#hooks.run.step.completed.emit({
 					projectId,
 					run: currentAlias,
 					turn: result.turn,
-					flags: result.flags,
 				});
+				if (verdict.continue) continue;
 
-				// Don't exit while budget recovery is still active.
-				if (recovery !== null) continue;
-
-				const repetition = healer.assessRepetition(result);
-				if (!repetition.continue) {
-					await this.#db.update_run_status.run({
-						id: currentRunId,
-						status: 200,
-					});
-					const out = {
-						run: currentAlias,
-						status: 200,
+				console.error(
+					`[LOOP] ${currentAlias} iter=${loopIteration} CLOSE status=${verdict.status} reason=${vReason}`,
+				);
+				await this.#setRunStatus(currentRunId, currentAlias, verdict.status);
+				if (verdict.reason) {
+					await this.#hooks.error.log.emit({
+						store: this.#entries,
+						runId: currentRunId,
 						turn: result.turn,
-						reason: repetition.reason,
-					};
-					await hook.completed.emit({ projectId, ...out });
-					return out;
+						loopId: currentLoopId,
+						message: verdict.reason,
+					});
 				}
-
-				const progress = healer.assessProgress(result);
-				if (progress.continue) continue;
-
-				await this.#db.update_run_status.run({
-					id: currentRunId,
-					status: 200,
-				});
 				const out = {
 					run: currentAlias,
-					status: 200,
+					status: verdict.status,
 					turn: result.turn,
+					reason: verdict.reason,
 				};
 				await hook.completed.emit({ projectId, ...out });
 				return out;
 			}
 
-			await this.#db.update_run_status.run({
-				id: currentRunId,
-				status: 200,
+			// MAX_TURNS exhaustion without a terminal update is abandonment.
+			console.error(
+				`[LOOP] ${currentAlias} hit MAX_LOOP_ITERATIONS=${MAX_LOOP_ITERATIONS} — abandoning at 499`,
+			);
+			await this.#setRunStatus(currentRunId, currentAlias, 499);
+			await this.#emitRunState({
+				projectId,
+				runId: currentRunId,
+				alias: currentAlias,
+				turn: loopIteration,
+				status: 499,
+				contextSize,
 			});
 			const out = {
 				run: currentAlias,
-				status: 200,
+				status: 499,
 				turn: loopIteration,
 			};
 			await hook.completed.emit({ projectId, ...out });
 			return out;
 		} catch (err) {
-			if (signal.aborted) {
-				await this.#db.update_run_status.run({
-					id: currentRunId,
-					status: 499,
+			const status = signal.aborted ? 499 : 500;
+			await this.#setRunStatus(currentRunId, currentAlias, status);
+			await this.#emitRunState({
+				projectId,
+				runId: currentRunId,
+				alias: currentAlias,
+				turn: loopIteration,
+				status,
+				contextSize,
+			});
+			if (status === 500) {
+				await this.#hooks.error.log.emit({
+					store: this.#entries,
+					runId: currentRunId,
+					turn: loopIteration,
+					loopId: currentLoopId,
+					message: `${err.message}\n${err.stack}`,
 				});
-				return { run: currentAlias, status: 499, turn: loopIteration };
 			}
-			console.warn(`[RUMMY] Run failed: ${err.message}`);
-			console.warn(`[RUMMY] Stack: ${err.stack}`);
-			await this.#db.update_run_status.run({
-				id: currentRunId,
-				status: 500,
-			});
-			try {
-				await this.#knownStore.upsert(
-					currentRunId,
-					loopIteration,
-					`error://${loopIteration}`,
-					`${err.message}\n${err.stack}`,
-					500,
-					{ loopId: currentLoopId },
-				);
-			} catch {}
-			const out = {
-				run: currentAlias,
-				status: 500,
-				turn: loopIteration,
-				error: err.message,
-			};
+			const out = { run: currentAlias, status, turn: loopIteration };
+			if (status === 500) out.error = err.message;
 			await hook.completed.emit({ projectId, ...out });
 			return out;
 		} finally {
-			await this.#hooks.loop.completed
-				.emit({
-					runId: currentRunId,
-					loopId: currentLoopId,
-					mode,
-					turns: loopIteration,
-				})
-				.catch(() => {});
+			await this.#hooks.loop.completed.emit({
+				runId: currentRunId,
+				loopId: currentLoopId,
+				mode,
+				turns: loopIteration,
+			});
 		}
 	}
 
@@ -529,119 +654,128 @@ export default class AgentLoop {
 
 		const { path, action, output } = resolution;
 
-		if (action === "accept" || action === "error") {
-			const attrs = await this.#knownStore.getAttributes(runId, path);
-			const resolvedBody = await this.#composeResolvedContent(
+		if (action !== "accept" && action !== "error" && action !== "reject") {
+			throw new Error(msg("error.resolution_invalid", { action }));
+		}
+
+		if (action === "reject") {
+			await this.#entries.set({
+				runId,
+				path,
+				state: "failed",
+				body: output ? output : "rejected",
+				outcome: "permission",
+			});
+			await this.#hooks.proposal.rejected.emit({
 				runId,
+				runRow,
 				path,
-				attrs,
 				output,
-			);
-			const status = action === "error" ? 500 : 200;
-			await this.#knownStore.resolve(runId, path, status, resolvedBody);
-
-			// Store answer in attributes for ask_user
-			if (path.startsWith("ask_user://") && output) {
-				const turn = (await this.#db.get_run_by_id.get({ id: runId }))
-					.next_turn;
-				await this.#knownStore.upsert(runId, turn, path, resolvedBody, status, {
-					attributes: { ...attrs, answer: output },
-				});
-			}
+				db: this.#db,
+				entries: this.#entries,
+			});
+			// Report the CURRENT run status (typically 102 mid-run) so the
+			// client's dispatch handler doesn't mistake a successful
+			// resolve's HTTP-style 200 ack for a terminal run status and
+			// prematurely close the document. Real terminal state comes
+			// from the run/state notification at end-of-turn.
+			return { run: runAlias, status: runRow.status };
+		}
 
-			if (action === "accept") {
-				const projectId = runRow.project_id;
-				const project = await this.#db.get_project_by_id.get({
-					id: projectId,
+		const attrs = await this.#entries.getAttributes(runId, path);
+		const project = await this.#db.get_project_by_id.get({
+			id: runRow.project_id,
+		});
+		const ctx = {
+			runId,
+			runRow,
+			projectId: runRow.project_id,
+			projectRoot: project?.project_root,
+			path,
+			attrs,
+			output,
+			db: this.#db,
+			entries: this.#entries,
+		};
+
+		// Plugins veto acceptance (e.g. readonly) via proposal.accepting.
+		// First veto wins: state=failed with plugin-supplied outcome + body.
+		if (action === "accept") {
+			const veto = await this.#hooks.proposal.accepting.filter(null, ctx);
+			if (veto?.allow === false) {
+				await this.#entries.set({
+					runId,
+					path,
+					state: "failed",
+					outcome: veto.outcome,
+					body: veto.body,
 				});
-				const projectRoot = project?.project_root;
-
-				if (path.startsWith("set://") && attrs?.file && attrs?.merge) {
-					const fileBody = await this.#knownStore.getBody(runId, attrs.file);
-					if (fileBody != null) {
-						const blocks = attrs.merge.split(/(?=<<<<<<< SEARCH)/);
-						let patched = fileBody;
-						for (const block of blocks) {
-							const m = block.match(
-								/<<<<<<< SEARCH\n?([\s\S]*?)\n?=======\n?([\s\S]*?)\n?>>>>>>> REPLACE/,
-							);
-							if (m) patched = patched.replace(m[1], m[2]);
-						}
-						const turn = (await this.#db.get_run_by_id.get({ id: runId }))
-							.next_turn;
-						await this.#knownStore.upsert(
-							runId,
-							turn,
-							attrs.file,
-							patched,
-							200,
-						);
-						// Write patched content to disk
-						if (projectRoot) {
-							const { writeFile } = await import("node:fs/promises");
-							const { join } = await import("node:path");
-							await writeFile(join(projectRoot, attrs.file), patched).catch(
-								() => {},
-							);
-						}
-					}
-				}
-
-				if (path.startsWith("rm://")) {
-					if (attrs?.path) {
-						await this.#knownStore.remove(runId, attrs.path);
-						if (projectRoot) {
-							const { unlink } = await import("node:fs/promises");
-							const { join } = await import("node:path");
-							await unlink(join(projectRoot, attrs.path)).catch(() => {});
-						}
-					}
-				}
-
-				if (path.startsWith("mv://")) {
-					if (attrs?.isMove && attrs?.from) {
-						await this.#knownStore.remove(runId, attrs.from);
-					}
-				}
+				return { ok: true, state: "failed", outcome: veto.outcome };
 			}
-		} else if (action === "reject") {
-			await this.#knownStore.resolve(runId, path, 403, output || "rejected");
-		} else {
-			throw new Error(msg("error.resolution_invalid", { action }));
 		}
 
-		// The dispatch loop is awaiting resolution. This unblocks it.
-		// Dispatch continuation is handled by the loop, not here.
-		return { run: runAlias, status: 200 };
-	}
+		// Compose the resolved body. Default is output || "". Plugins may
+		// override via proposal.content (e.g. set prefers the existing
+		// proposed body from the log entry).
+		const defaultBody = output ? output : "";
+		const resolvedBody = await this.#hooks.proposal.content.filter(
+			defaultBody,
+			ctx,
+		);
+		const state = action === "error" ? "failed" : "resolved";
+		const outcome = action === "error" ? "error" : null;
+		const existing = await this.#entries.getState(runId, path);
+		const existingTurn = existing?.turn === undefined ? 0 : existing.turn;
+		await this.#entries.set({
+			runId,
+			turn: existingTurn,
+			path,
+			state,
+			body: resolvedBody,
+			outcome,
+		});
 
-	async #composeResolvedContent(runId, path, _attrs, output) {
-		const scheme = path.split("://")[0];
-		switch (scheme) {
-			case "set": {
-				const existing = await this.#knownStore.getBody(runId, path);
-				return existing || output || "";
-			}
-			default:
-				return output || "";
-		}
+		const event =
+			action === "accept"
+				? this.#hooks.proposal.accepted
+				: this.#hooks.proposal.rejected;
+		await event.emit({ ...ctx, resolvedBody });
+
+		// Same rationale as the reject path: return current run status
+		// (102 mid-run) rather than a hardcoded 200 so the nvim client
+		// doesn't treat the RPC ack as a terminal signal.
+		return { run: runAlias, status: runRow.status };
 	}
 
-	async inject(runAlias, message) {
+	async inject(runAlias, message, mode, options = {}) {
+		if (mode !== "ask" && mode !== "act") {
+			throw new Error(
+				`inject: mode is required and must be "ask" or "act" (got ${JSON.stringify(mode)})`,
+			);
+		}
 		const runRow = await this.#db.get_run_by_alias.get({ alias: runAlias });
 		if (!runRow)
 			throw new Error(msg("error.run_not_found", { runId: runAlias }));
 
+		const noRepo = options?.noRepo ?? process.env.RUMMY_NO_REPO === "1";
+		const noInteraction =
+			options?.noInteraction ?? process.env.RUMMY_NO_INTERACTION === "1";
+		const noWeb = options?.noWeb ?? process.env.RUMMY_NO_WEB === "1";
+		const noProposals =
+			options?.noProposals ?? process.env.RUMMY_NO_PROPOSALS === "1";
+		const yolo = options?.yolo ?? process.env.RUMMY_YOLO === "1";
+
 		const nextTurn = runRow.next_turn;
 
-		await this.#knownStore.upsert(
-			runRow.id,
-			nextTurn,
-			`prompt://${nextTurn}`,
-			message,
-			200,
-			{ attributes: { mode: "ask" } },
-		);
+		await this.#entries.set({
+			runId: runRow.id,
+			turn: nextTurn,
+			path: `prompt://${nextTurn}`,
+			body: message,
+			state: "resolved",
+			attributes: { mode },
+			writer: "plugin",
+		});
 
 		if (this.#activeRuns.has(runRow.id)) {
 			return { run: runAlias, status: runRow.status, injected: "next_turn" };
@@ -651,31 +785,38 @@ export default class AgentLoop {
 		await this.#db.enqueue_loop.get({
 			run_id: runRow.id,
 			sequence: injectLoopSeq.sequence,
-			mode: "ask",
+			mode,
 			model: runRow.model,
 			prompt: message,
-			config: "{}",
+			config: JSON.stringify({
+				noRepo,
+				noInteraction,
+				noWeb,
+				noProposals,
+				yolo,
+				temperature: options?.temperature,
+			}),
 		});
 
 		const projectId = runRow.project_id;
 		const project = await this.#db.get_project_by_id.get({ id: projectId });
-		return this.#drainQueue(runRow.id, runAlias, projectId, project, {});
+		const controller = new AbortController();
+		const promise = this.#drainQueue(
+			runRow.id,
+			runAlias,
+			projectId,
+			project,
+			{},
+			controller,
+		);
+		this.#activeRuns.set(runRow.id, { controller, promise });
+		return promise;
 	}
 
 	async getRunHistory(runAlias) {
 		const runRow = await this.#db.get_run_by_alias.get({ alias: runAlias });
 		if (!runRow)
 			throw new Error(msg("error.run_not_found", { runId: runAlias }));
-		return this.#knownStore.getLog(runRow.id);
+		return this.#entries.getLog(runRow.id);
 	}
 }
-
-/**
- * Pure recovery state transition — exported for testing.
- *
- * @param {object|null} recovery  Current recovery state (mutated copy returned).
- * @param {{ assembledTokens: number, budgetRecovery?: { target: number, promptPath: string|null } }} result
- * @returns {{ next: object|null, action: null|'restore'|'hard413', promptPath: string|null }}
- */
-// Re-export for backward compatibility with tests
-export { advanceRecovery } from "../plugins/budget/recovery.js";