@possumtech/rummy 0.2.7 → 0.3.0

package/src/agent/AgentLoop.js

@@ -32,7 +32,7 @@ export default class AgentLoop {
 	}
 
 	async #ensureRun(projectId, model, run, options) {
-		const _noContext = options?.noContext === true;
+		const _noRepo = options?.noRepo === true;
 		const isFork = options?.fork === true;
 		const requestedModel = model;
 
@@ -54,6 +54,11 @@ export default class AgentLoop {
 				new_run_id: runRow.id,
 				parent_run_id: existingRun.id,
 			});
+			await this.#hooks.run.created.emit({
+				runId: runRow.id,
+				alias,
+				forkedFrom: existingRun.id,
+			});
 			return { runId: runRow.id, alias };
 		}
 
@@ -87,6 +92,7 @@ export default class AgentLoop {
 			persona: options?.persona ?? null,
 			context_limit: options?.contextLimit ?? null,
 		});
+		await this.#hooks.run.created.emit({ runId: runRow.id, alias });
 		return { runId: runRow.id, alias };
 	}
 
@@ -112,14 +118,16 @@ export default class AgentLoop {
 		if (!project)
 			throw new Error(msg("error.project_not_found", { projectId }));
 
-		const noContext = options?.noContext === true;
+		const noRepo = options?.noRepo === true;
+		const noInteraction = options?.noInteraction === true;
+		const noWeb = options?.noWeb === true;
 		const requestedModel = model;
 
 		const runInfo = await this.#ensureRun(projectId, model, run, options);
 		if (runInfo.blocked) {
 			return {
 				run: runInfo.alias,
-				status: "proposed",
+				status: 202,
 				remainingCount: runInfo.proposed.length,
 				proposed: runInfo.proposed,
 			};
@@ -127,16 +135,23 @@ export default class AgentLoop {
 
 		const { runId: currentRunId, alias: currentAlias } = runInfo;
 
-		await this.#db.enqueue_prompt.get({
+		const loopSeq = await this.#db.next_loop.get({ run_id: currentRunId });
+		await this.#db.enqueue_loop.get({
 			run_id: currentRunId,
+			sequence: loopSeq.sequence,
 			mode,
 			model: requestedModel,
 			prompt: prompt || "",
-			config: JSON.stringify({ noContext, temperature: options?.temperature }),
+			config: JSON.stringify({
+				noRepo,
+				noInteraction,
+				noWeb,
+				temperature: options?.temperature,
+			}),
 		});
 
 		if (this.#activeRuns.has(currentRunId)) {
-			return { run: currentAlias, status: "queued" };
+			return { run: currentAlias, status: 100 };
 		}
 
 		return this.#drainQueue(
@@ -149,36 +164,100 @@ export default class AgentLoop {
 	}
 
 	async #drainQueue(currentRunId, currentAlias, projectId, project, options) {
+		let panicAttempted = false;
+
 		while (true) {
-			const queued = await this.#db.claim_next_prompt.get({
+			const loop = await this.#db.claim_next_loop.get({
 				run_id: currentRunId,
 			});
-			if (!queued) break;
+			if (!loop) break;
+
+			const loopConfig = loop.config ? JSON.parse(loop.config) : {};
+			const hook =
+				loop.mode === "panic"
+					? this.#hooks.panic
+					: loop.mode === "ask"
+						? this.#hooks.ask
+						: this.#hooks.act;
 
-			const promptConfig = queued.config ? JSON.parse(queued.config) : {};
 			const result = await this.#executeLoop({
-				mode: queued.mode,
+				mode: loop.mode,
 				project,
 				projectId,
 				currentRunId,
 				currentAlias,
-				requestedModel: queued.model,
-				prompt: queued.prompt,
-				noContext: promptConfig.noContext || false,
-				options: { ...options, temperature: promptConfig.temperature },
-				hook: queued.mode === "ask" ? this.#hooks.ask : this.#hooks.act,
+				currentLoopId: loop.id,
+				requestedModel: loop.model,
+				prompt: loop.prompt,
+				noRepo: loopConfig.noRepo || false,
+				noInteraction: loopConfig.noInteraction || false,
+				noWeb: loopConfig.noWeb || false,
+				options: { ...options, temperature: loopConfig.temperature },
+				hook,
 			});
 
-			await this.#db.complete_prompt.run({
-				id: queued.id,
+			if (result.status === 413) {
+				await this.#db.complete_loop.run({
+					id: loop.id,
+					status: 413,
+					result: JSON.stringify(result),
+				});
+
+				// One panic attempt per drain cycle
+				if (loop.mode === "panic" || panicAttempted) {
+					return {
+						run: currentAlias,
+						status: 413,
+						error:
+							loop.mode === "panic"
+								? `Panic mode failed to free enough space (${result.overflow} tokens over).`
+								: `Context full (${result.overflow} tokens over).`,
+					};
+				}
+
+				panicAttempted = true;
+
+				const panicPrompt = this.#hooks.budget.panicPrompt({
+					assembledTokens: result.assembledTokens,
+					contextSize: result.contextSize,
+				});
+
+				// Enqueue panic loop
+				const panicSeq = await this.#db.next_loop.get({ run_id: currentRunId });
+				await this.#db.enqueue_loop.get({
+					run_id: currentRunId,
+					sequence: panicSeq.sequence,
+					mode: "panic",
+					model: loop.model,
+					prompt: panicPrompt,
+					config: JSON.stringify({ noRepo: true }),
+				});
+
+				// Re-enqueue the original loop to retry after panic
+				const retrySeq = await this.#db.next_loop.get({ run_id: currentRunId });
+				await this.#db.enqueue_loop.get({
+					run_id: currentRunId,
+					sequence: retrySeq.sequence,
+					mode: loop.mode,
+					model: loop.model,
+					prompt: loop.prompt,
+					config: loop.config,
+				});
+
+				continue;
+			}
+
+			await this.#db.complete_loop.run({
+				id: loop.id,
+				status: result.status === 202 ? 202 : result.status,
 				result: JSON.stringify(result),
 			});
 
-			if (result.status === "proposed") return result;
+			if (result.status === 202) return result;
 		}
 
 		const runRow = await this.#db.get_run_by_alias.get({ alias: currentAlias });
-		return { run: currentAlias, status: runRow?.status || "completed" };
+		return { run: currentAlias, status: runRow?.status ?? 200 };
 	}
 
 	async #executeLoop({
@@ -187,17 +266,20 @@ export default class AgentLoop {
 		projectId,
 		currentRunId,
 		currentAlias,
+		currentLoopId,
 		requestedModel,
 		prompt,
-		noContext,
+		noRepo,
+		noInteraction,
+		noWeb,
 		options,
 		hook,
 	}) {
 		const runRow = await this.#db.get_run_by_id.get({ id: currentRunId });
-		if (runRow.status !== "running") {
+		if (runRow.status !== 102) {
 			await this.#db.update_run_status.run({
 				id: currentRunId,
-				status: "running",
+				status: 102,
 			});
 		}
 
@@ -207,6 +289,11 @@ export default class AgentLoop {
 			? Math.min(runRow.context_limit, modelContextSize)
 			: modelContextSize;
 
+		const toolSet = this.#hooks.tools.resolveForLoop(mode, {
+			noInteraction,
+			noWeb,
+		});
+
 		let loopIteration = 0;
 		const MAX_LOOP_ITERATIONS = Number(process.env.RUMMY_MAX_TURNS) || 15;
 		const healer = new ResponseHealer();
@@ -214,16 +301,27 @@ export default class AgentLoop {
 		const controller = new AbortController();
 		this.#activeRuns.set(currentRunId, controller);
 
+		let _lastAssembledTokens = 0;
+		let _panicStrikes = 0;
+		let _lastPanicTokens = null;
+
+		await this.#hooks.loop.started.emit({
+			runId: currentRunId,
+			loopId: currentLoopId,
+			mode,
+			prompt,
+		});
+
 		try {
 			while (loopIteration < MAX_LOOP_ITERATIONS) {
 				if (controller.signal.aborted) {
 					await this.#db.update_run_status.run({
 						id: currentRunId,
-						status: "aborted",
+						status: 499,
 					});
 					const out = {
 						run: currentAlias,
-						status: "aborted",
+						status: 499,
 						turn: loopIteration,
 					};
 					await hook.completed.emit({ projectId, ...out });
@@ -234,6 +332,8 @@ export default class AgentLoop {
 				let turnPrompt;
 				if (loopIteration === 1) {
 					turnPrompt = prompt;
+				} else if (mode === "panic") {
+					turnPrompt = "Continue freeing space. Check <knowns> token counts.";
 				} else {
 					turnPrompt = this.#buildContinuationPrompt(
 						loopIteration,
@@ -247,14 +347,70 @@ export default class AgentLoop {
 					projectId,
 					currentRunId,
 					currentAlias,
+					currentLoopId,
 					requestedModel,
 					loopPrompt: turnPrompt,
-					noContext,
+					noRepo,
+					toolSet,
 					contextSize,
 					options: { ...options, isContinuation: loopIteration > 1 },
 					signal: controller.signal,
 				});
 
+				// Budget overflow — return 413 to drainQueue for panic mode
+				if (result.status === 413) {
+					return {
+						run: currentAlias,
+						status: 413,
+						overflow: result.overflow,
+						assembledTokens: result.assembledTokens,
+						contextSize: result.contextSize,
+						turn: result.turn,
+					};
+				}
+
+				_lastAssembledTokens = result.assembledTokens;
+
+				// Panic mode: target check + strike counting
+				if (mode === "panic") {
+					const panicTarget = Math.floor(contextSize * 0.75);
+					if (result.assembledTokens <= panicTarget) {
+						await this.#db.update_run_status.run({
+							id: currentRunId,
+							status: 200,
+						});
+						const out = {
+							run: currentAlias,
+							status: 200,
+							turn: result.turn,
+						};
+						await hook.completed.emit({ projectId, ...out });
+						return out;
+					}
+					if (_lastPanicTokens !== null) {
+						if (result.assembledTokens < _lastPanicTokens) {
+							_panicStrikes = 0;
+						} else {
+							_panicStrikes++;
+							if (_panicStrikes >= 3) {
+								await this.#db.update_run_status.run({
+									id: currentRunId,
+									status: 200,
+								});
+								return {
+									run: currentAlias,
+									status: 413,
+									overflow: result.assembledTokens - contextSize,
+									assembledTokens: result.assembledTokens,
+									contextSize,
+									turn: result.turn,
+								};
+							}
+						}
+					}
+					_lastPanicTokens = result.assembledTokens;
+				}
+
 				const runUsage = await this.#db.get_run_usage.get({
 					run_id: currentRunId,
 				});
@@ -265,14 +421,14 @@ export default class AgentLoop {
 				const unresolved = await this.#knownStore.getUnresolved(currentRunId);
 
 				const latestSummary = history
-					.filter((e) => e.status === "summary")
+					.filter((e) => e.status === 200 && e.path?.startsWith("summarize://"))
 					.at(-1);
 
 				await this.#hooks.run.state.emit({
 					projectId,
 					run: currentAlias,
 					turn: result.turn,
-					status: unresolved.length > 0 ? "proposed" : "running",
+					status: unresolved.length > 0 ? 202 : 102,
 					summary: latestSummary?.body || "",
 					history,
 					unknowns: unknowns.map((u) => ({ path: u.path, body: u.body })),
@@ -286,6 +442,12 @@ export default class AgentLoop {
 						model: result.model,
 						temperature: result.temperature,
 						context_size: result.contextSize,
+						context_tokens: (
+							await this.#db.get_turn_budget.get({
+								run_id: currentRunId,
+								turn: result.turn,
+							})
+						).total,
 						prompt_tokens: runUsage.prompt_tokens,
 						cached_tokens: runUsage.cached_tokens,
 						completion_tokens: runUsage.completion_tokens,
@@ -301,11 +463,11 @@ export default class AgentLoop {
 				if (unresolved.length > 0) {
 					await this.#db.update_run_status.run({
 						id: currentRunId,
-						status: "proposed",
+						status: 202,
 					});
 					const out = {
 						run: currentAlias,
-						status: "proposed",
+						status: 202,
 						turn: result.turn,
 						proposed: unresolved,
 					};
@@ -324,11 +486,11 @@ export default class AgentLoop {
 				if (!repetition.continue) {
 					await this.#db.update_run_status.run({
 						id: currentRunId,
-						status: "completed",
+						status: 200,
 					});
 					const out = {
 						run: currentAlias,
-						status: "completed",
+						status: 200,
 						turn: result.turn,
 						reason: repetition.reason,
 					};
@@ -341,11 +503,11 @@ export default class AgentLoop {
 
 				await this.#db.update_run_status.run({
 					id: currentRunId,
-					status: "completed",
+					status: 200,
 				});
 				const out = {
 					run: currentAlias,
-					status: "completed",
+					status: 200,
 					turn: result.turn,
 				};
 				await hook.completed.emit({ projectId, ...out });
@@ -354,11 +516,11 @@ export default class AgentLoop {
 
 			await this.#db.update_run_status.run({
 				id: currentRunId,
-				status: "completed",
+				status: 200,
 			});
 			const out = {
 				run: currentAlias,
-				status: "completed",
+				status: 200,
 				turn: loopIteration,
 			};
 			await hook.completed.emit({ projectId, ...out });
@@ -367,15 +529,15 @@ export default class AgentLoop {
 			if (controller.signal.aborted) {
 				await this.#db.update_run_status.run({
 					id: currentRunId,
-					status: "aborted",
+					status: 499,
 				});
-				return { run: currentAlias, status: "aborted", turn: loopIteration };
+				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: "failed",
+				status: 500,
 			});
 			try {
 				await this.#knownStore.upsert(
@@ -383,12 +545,13 @@ export default class AgentLoop {
 					loopIteration,
 					`error://${loopIteration}`,
 					`${err.message}\n${err.stack}`,
-					"info",
+					500,
+					{ loopId: currentLoopId },
 				);
 			} catch {}
 			const out = {
 				run: currentAlias,
-				status: "failed",
+				status: 500,
 				turn: loopIteration,
 				error: err.message,
 			};
@@ -396,6 +559,14 @@ export default class AgentLoop {
 			return out;
 		} finally {
 			this.#activeRuns.delete(currentRunId);
+			await this.#hooks.loop.completed
+				.emit({
+					runId: currentRunId,
+					loopId: currentLoopId,
+					mode,
+					turns: loopIteration,
+				})
+				.catch(() => {});
 		}
 	}
 
@@ -415,14 +586,14 @@ export default class AgentLoop {
 				attrs,
 				output,
 			);
-			const state = action === "error" ? "error" : "pass";
-			await this.#knownStore.resolve(runId, path, state, resolvedBody);
+			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, state, {
+				await this.#knownStore.upsert(runId, turn, path, resolvedBody, status, {
 					attributes: { ...attrs, answer: output },
 				});
 			}
@@ -441,12 +612,7 @@ export default class AgentLoop {
 				}
 			}
 		} else if (action === "reject") {
-			await this.#knownStore.resolve(
-				runId,
-				path,
-				"rejected",
-				output || "rejected",
-			);
+			await this.#knownStore.resolve(runId, path, 403, output || "rejected");
 		} else {
 			throw new Error(msg("error.resolution_invalid", { action }));
 		}
@@ -455,23 +621,46 @@ export default class AgentLoop {
 		if (unresolved.length > 0) {
 			return {
 				run: runAlias,
-				status: "proposed",
+				status: 202,
 				remainingCount: unresolved.length,
 				proposed: unresolved,
 			};
 		}
 
-		if (await this.#knownStore.hasRejections(runId)) {
-			await this.#db.update_run_status.run({ id: runId, status: "completed" });
-			return { run: runAlias, status: "completed" };
+		// Scope completion checks to the current loop
+		const currentLoop = await this.#db.get_current_loop.get({ run_id: runId });
+		const loopId = currentLoop?.id ?? null;
+
+		if (await this.#knownStore.hasRejections(runId, loopId)) {
+			if (currentLoop)
+				await this.#db.complete_loop.run({
+					id: loopId,
+					status: 200,
+					result: null,
+				});
+			await this.#db.update_run_status.run({ id: runId, status: 200 });
+			return { run: runAlias, status: 200 };
 		}
 
-		const hasSummary = await this.#db.get_latest_summary.get({ run_id: runId });
+		const hasSummary = await this.#db.get_latest_summary.get({
+			run_id: runId,
+			loop_id: loopId,
+		});
 		if (hasSummary?.body) {
-			await this.#db.update_run_status.run({ id: runId, status: "completed" });
-			return { run: runAlias, status: "completed" };
+			if (currentLoop)
+				await this.#db.complete_loop.run({
+					id: loopId,
+					status: 200,
+					result: null,
+				});
+			await this.#db.update_run_status.run({ id: runId, status: 200 });
+			return { run: runAlias, status: 200 };
 		}
 
+		// No summary and no rejections in this loop — resume it
+		const projectId = runRow.project_id;
+		const project = await this.#db.get_project_by_id.get({ id: projectId });
+
 		const latestPrompt = await this.#db.get_latest_prompt.get({
 			run_id: runId,
 		});
@@ -479,11 +668,11 @@ export default class AgentLoop {
 			? JSON.parse(latestPrompt.attributes).mode
 			: "ask";
 
-		const projectId = runRow.project_id;
-		const project = await this.#db.get_project_by_id.get({ id: projectId });
-
-		await this.#db.enqueue_prompt.get({
+		// Re-enqueue the current loop's prompt to continue it
+		const loopSeq = await this.#db.next_loop.get({ run_id: runId });
+		await this.#db.enqueue_loop.get({
 			run_id: runId,
+			sequence: loopSeq.sequence,
 			mode: resumeMode,
 			model: runRow.model,
 			prompt: "",
@@ -515,24 +704,19 @@ export default class AgentLoop {
 			runRow.id,
 			nextTurn,
 			`prompt://${nextTurn}`,
-			"",
-			"info",
-			{ attributes: { mode: "ask" } },
-		);
-		await this.#knownStore.upsert(
-			runRow.id,
-			nextTurn,
-			`ask://${nextTurn}`,
 			message,
-			"info",
+			200,
+			{ attributes: { mode: "ask" } },
 		);
 
 		if (this.#activeRuns.has(runRow.id)) {
 			return { run: runAlias, status: runRow.status, injected: "next_turn" };
 		}
 
-		await this.#db.enqueue_prompt.get({
+		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: "ask",
 			model: runRow.model,
 			prompt: message,

package/src/agent/ContextAssembler.js

@@ -6,17 +6,31 @@
 export default class ContextAssembler {
 	static async assembleFromTurnContext(
 		rows,
-		{ type = "ask", systemPrompt = "", contextSize = 0 } = {},
+		{
+			type = "ask",
+			systemPrompt = "",
+			contextSize = 0,
+			demoted = [],
+			toolSet = null,
+			lastContextTokens = 0,
+		} = {},
 		hooks,
 	) {
 		// Find loop boundary from active prompt
 		const promptEntry = rows.findLast(
-			(r) =>
-				r.category === "prompt" && (r.scheme === "ask" || r.scheme === "act"),
+			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
 		const loopStartTurn = promptEntry?.source_turn ?? 0;
 
-		const ctx = { rows, loopStartTurn, type, contextSize };
+		const ctx = {
+			rows,
+			loopStartTurn,
+			type,
+			contextSize,
+			lastContextTokens,
+			demoted,
+			toolSet,
+		};
 
 		const system = await hooks.assembly.system.filter(systemPrompt, ctx);
 		const user = await hooks.assembly.user.filter("", ctx);