@possumtech/rummy 2.0.1 → 2.2.0

package/src/agent/AgentLoop.js

@@ -1,6 +1,20 @@
-import { computeBudget } from "./budget.js";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import msg from "./messages.js";
 
+const DEFAULT_PERSONA_PATH = join(
+	dirname(fileURLToPath(import.meta.url)),
+	"../plugins/persona/default.md",
+);
+let cachedDefaultPersona = null;
+async function loadDefaultPersona() {
+	if (cachedDefaultPersona == null) {
+		cachedDefaultPersona = await readFile(DEFAULT_PERSONA_PATH, "utf8");
+	}
+	return cachedDefaultPersona;
+}
+
 const HTTP_TO_RUN_STATE = {
 	100: "proposed",
 	102: "streaming",
@@ -24,6 +38,11 @@ export default class AgentLoop {
 		this.#hooks = hooks;
 		this.#turnExecutor = turnExecutor;
 		this.#entries = entries;
+		hooks.run.wake.on(this.#onWake.bind(this));
+	}
+
+	async #onWake({ runAlias, body, mode }) {
+		await this.inject(runAlias, body, mode);
 	}
 
 	abort(runId) {
@@ -31,20 +50,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 +68,25 @@ 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,
+			runId,
+			...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,76 +99,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 = 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,
@@ -173,10 +134,12 @@ export default class AgentLoop {
 		const {
 			fork: isFork = false,
 			temperature = null,
-			persona = null,
+			persona: personaOpt = null,
 			contextLimit = null,
 		} = options;
 		const requestedModel = model;
+		let persona = personaOpt;
+		if (!persona) persona = await loadDefaultPersona();
 
 		if (run && isFork) {
 			const existingRun = await this.#db.get_run_by_alias.get({ alias: run });
@@ -193,6 +156,12 @@ export default class AgentLoop {
 				context_limit: contextLimit,
 			});
 			await this.#entries.forkEntries(existingRun.id, runRow.id);
+			// Absolute turn numbering across the lineage; SPEC
+			// §budget_enforcement. Without this, the fork's first
+			// dispatch lands at turn 1 while inherited run_views carry
+			// parent-side turn values, and the budget grinder's
+			// `current_turn − 1` rule sees nothing meaningful.
+			await this.#entries.setNextTurn(runRow.id, existingRun.next_turn);
 			await this.#writeRunEntry(runRow.id, alias, prompt, {
 				projectId,
 				parentRunId: existingRun.id,
@@ -215,7 +184,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({
@@ -228,7 +196,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);
@@ -314,8 +281,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,
@@ -465,7 +431,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,
@@ -475,31 +441,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;
@@ -508,7 +466,7 @@ export default class AgentLoop {
 				} else {
 					turnPrompt = this.#buildContinuationPrompt(
 						loopIteration,
-						MAX_LOOP_ITERATIONS,
+						MAX_LOOP_TURNS,
 					);
 				}
 
@@ -539,29 +497,23 @@ export default class AgentLoop {
 					`[LOOP] ${currentAlias} iter=${loopIteration} turn done: status=${result.status} turn=${result.turn}`,
 				);
 
-				const verdict = await this.#hooks.error.verdict({
-					store: this.#entries,
-					runId: currentRunId,
-					loopId: currentLoopId,
-					turn: result.turn,
-					recorded: result.recorded,
-					summaryText: result.summaryText,
-				});
+				const verdict = await this.#hooks.turn.verdict.filter(
+					{ continue: true },
+					{
+						store: this.#entries,
+						runId: currentRunId,
+						loopId: currentLoopId,
+						turn: result.turn,
+						recorded: result.recorded,
+						summaryText: result.summaryText,
+					},
+				);
 				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.#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,
@@ -588,41 +540,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,
@@ -634,7 +569,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({
@@ -674,11 +609,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 };
 		}
 
@@ -698,8 +629,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) {
@@ -714,9 +644,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,
@@ -741,9 +669,7 @@ 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 };
 	}
 
@@ -767,6 +693,40 @@ export default class AgentLoop {
 
 		const nextTurn = runRow.next_turn;
 
+		// Resolve the owning loop_id BEFORE writing the prompt entry so
+		// it lands with correct loop scope. Active run → reuse the
+		// running loop; otherwise enqueue the next loop and write the
+		// prompt with the new loop's id.
+		let loopId;
+		if (this.#activeRuns.has(runRow.id)) {
+			// Active runs have exactly one loop at status=102 by the
+			// loops table invariant — trust the contract.
+			const currentLoop = await this.#db.get_current_loop.get({
+				run_id: runRow.id,
+			});
+			loopId = currentLoop.id;
+		} else {
+			const injectLoopSeq = await this.#db.next_loop.get({
+				run_id: runRow.id,
+			});
+			const enqueued = await this.#db.enqueue_loop.get({
+				run_id: runRow.id,
+				sequence: injectLoopSeq.sequence,
+				mode,
+				model: runRow.model,
+				prompt: message,
+				config: JSON.stringify({
+					noRepo,
+					noInteraction,
+					noWeb,
+					noProposals,
+					yolo,
+					temperature: options?.temperature,
+				}),
+			});
+			loopId = enqueued.id;
+		}
+
 		await this.#entries.set({
 			runId: runRow.id,
 			turn: nextTurn,
@@ -774,6 +734,7 @@ export default class AgentLoop {
 			body: message,
 			state: "resolved",
 			attributes: { mode },
+			loopId,
 			writer: "plugin",
 		});
 
@@ -781,23 +742,6 @@ export default class AgentLoop {
 			return { run: runAlias, status: runRow.status, injected: "next_turn" };
 		}
 
-		const injectLoopSeq = await this.#db.next_loop.get({ run_id: runRow.id });
-		await this.#db.enqueue_loop.get({
-			run_id: runRow.id,
-			sequence: injectLoopSeq.sequence,
-			mode,
-			model: runRow.model,
-			prompt: message,
-			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 });
 		const controller = new AbortController();

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,14 @@ export default class ContextAssembler {
 			type = "ask",
 			systemPrompt = "",
 			contextSize = 0,
-			demoted = [],
 			toolSet = null,
 			lastContextTokens = 0,
 			turn = 1,
+			persona = "",
 		} = {},
 		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,9 +26,9 @@ export default class ContextAssembler {
 			type,
 			contextSize,
 			lastContextTokens,
-			demoted,
 			toolSet,
 			turn,
+			persona,
 		};
 
 		const system = await hooks.assembly.system.filter(systemPrompt, ctx);