@possumtech/rummy 2.0.0 → 2.1.0

package/src/agent/AgentLoop.js

@@ -1,4 +1,3 @@
-import { computeBudget } from "./budget.js";
 import msg from "./messages.js";
 
 const HTTP_TO_RUN_STATE = {
@@ -31,20 +30,13 @@ export default class AgentLoop {
 		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.
-	 */
+	// Abort all in-flight runs and drain; rejections were already surfaced to original awaiters.
 	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);
 	}
 
@@ -56,6 +48,24 @@ export default class AgentLoop {
 		return `Turn ${turn}/${maxTurns}`;
 	}
 
+	async #emitCompleted(hook, projectId, runId, out) {
+		const s = await this.#db.get_run_summary.get({ id: runId });
+		await hook.completed.emit({
+			projectId,
+			...out,
+			model: s.model,
+			turns: s.turns,
+			cost: s.cost,
+			tokens: {
+				prompt: s.prompt_tokens,
+				cached: s.cached_tokens,
+				completion: s.completion_tokens,
+				reasoning: s.reasoning_tokens,
+				total: s.total_tokens,
+			},
+		});
+	}
+
 	async #setRunStatus(runId, alias, httpStatus) {
 		await this.#db.update_run_status.run({ id: runId, status: httpStatus });
 		const state = HTTP_TO_RUN_STATE[httpStatus];
@@ -68,88 +78,6 @@ export default class AgentLoop {
 		});
 	}
 
-	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 = history
-			.filter((e) => {
-				// Updates are under the unified log namespace at
-				// log://turn_N/update/<slug>. Match by path pattern rather
-				// than scheme (scheme is now "log" for all log entries).
-				if (!/^log:\/\/turn_\d+\/update\//.test(e.path)) return false;
-				const attrs =
-					typeof e.attributes === "string"
-						? JSON.parse(e.attributes)
-						: e.attributes;
-				return attrs?.status === 200;
-			})
-			.at(-1);
-
-		// 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,
@@ -227,7 +155,6 @@ export default class AgentLoop {
 				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({
@@ -240,7 +167,6 @@ export default class AgentLoop {
 				}
 				return { runId: existingRun.id, alias: existingRun.alias };
 			}
-			// Client-specified alias for a brand-new run — accept it verbatim.
 		}
 
 		const alias = run ? run : await this.#generateAlias(requestedModel);
@@ -287,10 +213,13 @@ 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(
@@ -314,6 +243,7 @@ export default class AgentLoop {
 				noInteraction,
 				noWeb,
 				noProposals,
+				yolo,
 				temperature: options?.temperature,
 			}),
 		});
@@ -322,8 +252,7 @@ export default class AgentLoop {
 			return { run: currentAlias, status: 100 };
 		}
 
-		// Allocate the controller + Promise pair here so `abortAll` can
-		// reach both — abort the controller, await the Promise's drain.
+		// Pair controller + Promise so abortAll can both signal and await drain.
 		const controller = new AbortController();
 		const promise = this.#drainQueue(
 			currentRunId,
@@ -367,6 +296,7 @@ export default class AgentLoop {
 					noInteraction = false,
 					noWeb = false,
 					noProposals = false,
+					yolo = false,
 				} = loopConfig;
 
 				let result;
@@ -384,6 +314,7 @@ export default class AgentLoop {
 						noInteraction,
 						noWeb,
 						noProposals,
+						yolo,
 						options: { ...options, temperature: loopConfig.temperature },
 						hook,
 						signal: controller.signal,
@@ -448,6 +379,7 @@ export default class AgentLoop {
 		noInteraction,
 		noWeb,
 		noProposals,
+		yolo,
 		options,
 		hook,
 		signal,
@@ -470,7 +402,7 @@ export default class AgentLoop {
 		});
 
 		let loopIteration = 0;
-		const MAX_LOOP_ITERATIONS = Number(process.env.RUMMY_MAX_TURNS);
+		const MAX_LOOP_TURNS = Number(process.env.RUMMY_MAX_LOOP_TURNS);
 
 		await this.#hooks.loop.started.emit({
 			runId: currentRunId,
@@ -480,31 +412,23 @@ export default class AgentLoop {
 		});
 
 		try {
-			while (loopIteration < MAX_LOOP_ITERATIONS) {
+			while (loopIteration < MAX_LOOP_TURNS) {
 				if (signal.aborted) {
 					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,
 						status: 499,
 						turn: loopIteration,
 					};
-					await hook.completed.emit({ projectId, ...out });
+					await this.#emitCompleted(hook, projectId, currentRunId, out);
 					return out;
 				}
 				loopIteration++;
 				console.error(
-					`[LOOP] ${currentAlias} iter=${loopIteration} ENTER (max=${MAX_LOOP_ITERATIONS})`,
+					`[LOOP] ${currentAlias} iter=${loopIteration} ENTER (max=${MAX_LOOP_TURNS})`,
 				);
 
 				let turnPrompt;
@@ -513,7 +437,7 @@ export default class AgentLoop {
 				} else {
 					turnPrompt = this.#buildContinuationPrompt(
 						loopIteration,
-						MAX_LOOP_ITERATIONS,
+						MAX_LOOP_TURNS,
 					);
 				}
 
@@ -534,6 +458,7 @@ export default class AgentLoop {
 					noWeb,
 					noInteraction,
 					noProposals,
+					yolo,
 					toolSet,
 					contextSize,
 					options: { ...options, isContinuation: loopIteration > 1 },
@@ -557,15 +482,6 @@ export default class AgentLoop {
 					`[LOOP] ${currentAlias} iter=${loopIteration} verdict: continue=${verdict.continue} status=${vStatus} reason=${vReason}`,
 				);
 
-				await this.#emitRunState({
-					projectId,
-					runId: currentRunId,
-					alias: currentAlias,
-					turn: result.turn,
-					status: verdict.continue ? 102 : verdict.status,
-					contextSize,
-					result,
-				});
 				await this.#hooks.run.step.completed.emit({
 					projectId,
 					run: currentAlias,
@@ -592,41 +508,24 @@ export default class AgentLoop {
 					turn: result.turn,
 					reason: verdict.reason,
 				};
-				await hook.completed.emit({ projectId, ...out });
+				await this.#emitCompleted(hook, projectId, currentRunId, out);
 				return out;
 			}
 
-			// MAX_TURNS exhaustion without a terminal update is abandonment.
 			console.error(
-				`[LOOP] ${currentAlias} hit MAX_LOOP_ITERATIONS=${MAX_LOOP_ITERATIONS} — abandoning at 499`,
+				`[LOOP] ${currentAlias} hit MAX_LOOP_TURNS=${MAX_LOOP_TURNS} — 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: 499,
 				turn: loopIteration,
 			};
-			await hook.completed.emit({ projectId, ...out });
+			await this.#emitCompleted(hook, projectId, currentRunId, out);
 			return out;
 		} catch (err) {
 			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,
@@ -638,7 +537,7 @@ export default class AgentLoop {
 			}
 			const out = { run: currentAlias, status, turn: loopIteration };
 			if (status === 500) out.error = err.message;
-			await hook.completed.emit({ projectId, ...out });
+			await this.#emitCompleted(hook, projectId, currentRunId, out);
 			return out;
 		} finally {
 			await this.#hooks.loop.completed.emit({
@@ -678,11 +577,7 @@ export default class AgentLoop {
 				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 current run status (not 200) so client doesn't close on resolve ack.
 			return { run: runAlias, status: runRow.status };
 		}
 
@@ -702,8 +597,7 @@ export default class AgentLoop {
 			entries: this.#entries,
 		};
 
-		// Plugins veto acceptance (e.g. readonly) via proposal.accepting.
-		// First veto wins: state=failed with plugin-supplied outcome + body.
+		// First plugin veto wins via proposal.accepting (e.g. readonly).
 		if (action === "accept") {
 			const veto = await this.#hooks.proposal.accepting.filter(null, ctx);
 			if (veto?.allow === false) {
@@ -718,9 +612,7 @@ export default class AgentLoop {
 			}
 		}
 
-		// 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).
+		// proposal.content override lets plugins prefer the proposed body (e.g. set).
 		const defaultBody = output ? output : "";
 		const resolvedBody = await this.#hooks.proposal.content.filter(
 			defaultBody,
@@ -745,13 +637,11 @@ export default class AgentLoop {
 				: 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 current run status (not 200) so client doesn't close on resolve ack.
 		return { run: runAlias, status: runRow.status };
 	}
 
-	async inject(runAlias, message, mode) {
+	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)})`,
@@ -761,6 +651,14 @@ export default class AgentLoop {
 		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.#entries.set({
@@ -784,7 +682,14 @@ export default class AgentLoop {
 			mode,
 			model: runRow.model,
 			prompt: message,
-			config: "{}",
+			config: JSON.stringify({
+				noRepo,
+				noInteraction,
+				noWeb,
+				noProposals,
+				yolo,
+				temperature: options?.temperature,
+			}),
 		});
 
 		const projectId = runRow.project_id;

package/src/agent/ContextAssembler.js

@@ -1,8 +1,4 @@
-/**
- * Thin orchestrator. Computes loopStartTurn from the rows,
- * then invokes assembly.system and assembly.user filter chains.
- * All rendering logic lives in plugins.
- */
+// Orchestrates assembly.system / assembly.user filter chains; plugins do all rendering.
 export default class ContextAssembler {
 	static async assembleFromTurnContext(
 		rows,
@@ -10,15 +6,13 @@ export default class ContextAssembler {
 			type = "ask",
 			systemPrompt = "",
 			contextSize = 0,
-			demoted = [],
 			toolSet = null,
 			lastContextTokens = 0,
 			turn = 1,
 		} = {},
 		hooks,
 	) {
-		// Find loop boundary from active prompt. Absent on turn 1 before
-		// the prompt plugin's turn.started handler has run.
+		// Loop boundary from active prompt; absent on turn 1 before prompt plugin's turn.started.
 		const promptEntry = rows.findLast(
 			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
@@ -31,7 +25,6 @@ export default class ContextAssembler {
 			type,
 			contextSize,
 			lastContextTokens,
-			demoted,
 			toolSet,
 			turn,
 		};