@possumtech/rummy 0.3.0 → 0.3.1

package/src/agent/AgentLoop.js

@@ -121,6 +121,7 @@ export default class AgentLoop {
 		const noRepo = options?.noRepo === true;
 		const noInteraction = options?.noInteraction === true;
 		const noWeb = options?.noWeb === true;
+		const noProposals = options?.noProposals === true;
 		const requestedModel = model;
 
 		const runInfo = await this.#ensureRun(projectId, model, run, options);
@@ -146,6 +147,7 @@ export default class AgentLoop {
 				noRepo,
 				noInteraction,
 				noWeb,
+				noProposals,
 				temperature: options?.temperature,
 			}),
 		});
@@ -164,100 +166,76 @@ export default class AgentLoop {
 	}
 
 	async #drainQueue(currentRunId, currentAlias, projectId, project, options) {
-		let panicAttempted = false;
-
-		while (true) {
-			const loop = await this.#db.claim_next_loop.get({
-				run_id: currentRunId,
-			});
-			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 result = await this.#executeLoop({
-				mode: loop.mode,
-				project,
-				projectId,
-				currentRunId,
-				currentAlias,
-				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,
-			});
+		const controller = new AbortController();
+		this.#activeRuns.set(currentRunId, controller);
 
-			if (result.status === 413) {
-				await this.#db.complete_loop.run({
-					id: loop.id,
-					status: 413,
-					result: JSON.stringify(result),
+		try {
+			while (true) {
+				const loop = await this.#db.claim_next_loop.get({
+					run_id: currentRunId,
 				});
+				if (!loop) break;
+
+				const loopConfig = loop.config ? JSON.parse(loop.config) : {};
+				const hook = loop.mode === "ask" ? this.#hooks.ask : this.#hooks.act;
+
+				let result;
+				try {
+					result = await this.#executeLoop({
+						mode: loop.mode,
+						project,
+						projectId,
+						currentRunId,
+						currentAlias,
+						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,
+						options: { ...options, temperature: loopConfig.temperature },
+						hook,
+						signal: controller.signal,
+					});
+				} catch (err) {
+					await this.#db.complete_loop.run({
+						id: loop.id,
+						status: 500,
+						result: JSON.stringify({ error: err.message }),
+					});
+					throw err;
+				}
 
-				// One panic attempt per drain cycle
-				if (loop.mode === "panic" || panicAttempted) {
+				if (result.status === 413) {
+					await this.#db.complete_loop.run({
+						id: loop.id,
+						status: 413,
+						result: JSON.stringify(result),
+					});
 					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).`,
+						error: `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,
+				await this.#db.complete_loop.run({
+					id: loop.id,
+					status: result.status === 202 ? 202 : result.status,
+					result: JSON.stringify(result),
 				});
 
-				continue;
+				if (result.status === 202) return result;
 			}
 
-			await this.#db.complete_loop.run({
-				id: loop.id,
-				status: result.status === 202 ? 202 : result.status,
-				result: JSON.stringify(result),
+			const runRow = await this.#db.get_run_by_alias.get({
+				alias: currentAlias,
 			});
-
-			if (result.status === 202) return result;
+			return { run: currentAlias, status: runRow?.status ?? 200 };
+		} finally {
+			this.#activeRuns.delete(currentRunId);
 		}
-
-		const runRow = await this.#db.get_run_by_alias.get({ alias: currentAlias });
-		return { run: currentAlias, status: runRow?.status ?? 200 };
 	}
 
 	async #executeLoop({
@@ -272,8 +250,10 @@ export default class AgentLoop {
 		noRepo,
 		noInteraction,
 		noWeb,
+		noProposals,
 		options,
 		hook,
+		signal,
 	}) {
 		const runRow = await this.#db.get_run_by_id.get({ id: currentRunId });
 		if (runRow.status !== 102) {
@@ -292,18 +272,27 @@ export default class AgentLoop {
 		const toolSet = this.#hooks.tools.resolveForLoop(mode, {
 			noInteraction,
 			noWeb,
+			noProposals,
 		});
 
 		let loopIteration = 0;
 		const MAX_LOOP_ITERATIONS = Number(process.env.RUMMY_MAX_TURNS) || 15;
 		const healer = new ResponseHealer();
 
-		const controller = new AbortController();
-		this.#activeRuns.set(currentRunId, controller);
-
 		let _lastAssembledTokens = 0;
-		let _panicStrikes = 0;
-		let _lastPanicTokens = null;
+		let recovery = null; // { target, promptPath, strikes, lastTokens }
+
+		// Demote full logging entries from previous loops to summary before
+		// they appear in <previous>. General policy: keep <previous> compact.
+		await this.#knownStore.demotePreviousLoopLogging(
+			currentRunId,
+			currentLoopId,
+		);
+
+		// 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);
 
 		await this.#hooks.loop.started.emit({
 			runId: currentRunId,
@@ -314,7 +303,7 @@ export default class AgentLoop {
 
 		try {
 			while (loopIteration < MAX_LOOP_ITERATIONS) {
-				if (controller.signal.aborted) {
+				if (signal.aborted) {
 					await this.#db.update_run_status.run({
 						id: currentRunId,
 						status: 499,
@@ -332,8 +321,6 @@ 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,
@@ -350,14 +337,15 @@ export default class AgentLoop {
 					currentLoopId,
 					requestedModel,
 					loopPrompt: turnPrompt,
+					loopIteration,
 					noRepo,
 					toolSet,
+					inRecovery: recovery !== null,
 					contextSize,
 					options: { ...options, isContinuation: loopIteration > 1 },
-					signal: controller.signal,
+					signal,
 				});
 
-				// Budget overflow — return 413 to drainQueue for panic mode
 				if (result.status === 413) {
 					return {
 						run: currentAlias,
@@ -371,44 +359,28 @@ export default class AgentLoop {
 
 				_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;
+				// 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,
+						"full",
+					);
+				}
+				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({
@@ -442,12 +414,13 @@ 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,
+						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,
@@ -482,6 +455,9 @@ export default class AgentLoop {
 					flags: result.flags,
 				});
 
+				// 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({
@@ -526,7 +502,7 @@ export default class AgentLoop {
 			await hook.completed.emit({ projectId, ...out });
 			return out;
 		} catch (err) {
-			if (controller.signal.aborted) {
+			if (signal.aborted) {
 				await this.#db.update_run_status.run({
 					id: currentRunId,
 					status: 499,
@@ -558,7 +534,6 @@ export default class AgentLoop {
 			await hook.completed.emit({ projectId, ...out });
 			return out;
 		} finally {
-			this.#activeRuns.delete(currentRunId);
 			await this.#hooks.loop.completed
 				.emit({
 					runId: currentRunId,
@@ -599,6 +574,29 @@ export default class AgentLoop {
 			}
 
 			if (action === "accept") {
+				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,
+						);
+					}
+				}
+
 				if (path.startsWith("rm://")) {
 					if (attrs?.path) {
 						await this.#knownStore.remove(runId, attrs.path);
@@ -676,7 +674,7 @@ export default class AgentLoop {
 			mode: resumeMode,
 			model: runRow.model,
 			prompt: "",
-			config: "{}",
+			config: currentLoop?.config || "{}",
 		});
 		return this.#drainQueue(runId, runAlias, projectId, project, {});
 	}
@@ -735,3 +733,51 @@ export default class AgentLoop {
 		return this.#knownStore.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 }}
+ */
+export function advanceRecovery(recovery, result) {
+	// Initialise or update recovery state from a new Turn Demotion event.
+	if (result.budgetRecovery) {
+		if (!recovery) {
+			recovery = {
+				target: result.budgetRecovery.target,
+				promptPath: result.budgetRecovery.promptPath,
+				strikes: 0,
+				lastTokens: result.assembledTokens,
+			};
+		} else {
+			// Re-overflow during recovery: tighten target, don't count as strike.
+			recovery = {
+				...recovery,
+				target: Math.min(recovery.target, result.budgetRecovery.target),
+			};
+		}
+	}
+
+	if (recovery === null) return { next: null, action: null, promptPath: null };
+
+	const current = result.assembledTokens;
+
+	if (current <= recovery.target) {
+		return { next: null, action: "restore", promptPath: recovery.promptPath };
+	}
+
+	const noProgress = current >= recovery.lastTokens && !result.budgetRecovery;
+	const strikes = noProgress ? recovery.strikes + 1 : 0;
+
+	if (strikes >= 3) {
+		return { next: null, action: "hard413", promptPath: null };
+	}
+
+	return {
+		next: { ...recovery, strikes, lastTokens: current },
+		action: null,
+		promptPath: null,
+	};
+}

package/src/agent/ContextAssembler.js

@@ -13,6 +13,7 @@ export default class ContextAssembler {
 			demoted = [],
 			toolSet = null,
 			lastContextTokens = 0,
+			turn = 1,
 		} = {},
 		hooks,
 	) {
@@ -30,6 +31,7 @@ export default class ContextAssembler {
 			lastContextTokens,
 			demoted,
 			toolSet,
+			turn,
 		};
 
 		const system = await hooks.assembly.system.filter(systemPrompt, ctx);

package/src/agent/KnownStore.js

@@ -1,25 +1,16 @@
 import slugify from "../sql/functions/slugify.js";
-import { countTokens } from "./tokens.js";
 
 export default class KnownStore {
 	#db;
 	#onChanged;
-	#budgetGuard = null;
 	#schemes = new Map();
+	#seq = 0;
 
 	constructor(db, { onChanged } = {}) {
 		this.#db = db;
 		this.#onChanged = onChanged || null;
 	}
 
-	get budgetGuard() {
-		return this.#budgetGuard;
-	}
-
-	set budgetGuard(guard) {
-		this.#budgetGuard = guard;
-	}
-
 	async loadSchemes(db) {
 		const rows = await (db || this.#db).get_all_schemes.all();
 		this.#schemes.clear();
@@ -28,13 +19,6 @@ export default class KnownStore {
 		}
 	}
 
-	#isVisible(path, fidelity) {
-		if (fidelity === "archive") return false;
-		const scheme = KnownStore.scheme(path) ?? "file";
-		const meta = this.#schemes.get(scheme);
-		return meta ? meta.model_visible !== 0 : true;
-	}
-
 	#emitChanged(runId, path, changeType) {
 		if (this.#onChanged) this.#onChanged({ runId, path, changeType });
 	}
@@ -46,15 +30,16 @@ export default class KnownStore {
 
 	static normalizePath(path) {
 		if (!path?.includes("://")) return path;
-		return path.replace(/:\/\/(.*)$/, (_, rest) => {
-			try {
-				// Decode first (idempotent), then encode — but preserve slashes
-				const decoded = decodeURIComponent(rest);
-				return `://${decoded.split("/").map(encodeURIComponent).join("/")}`;
-			} catch {
-				return `://${rest.split("/").map(encodeURIComponent).join("/")}`;
-			}
-		});
+		const sep = path.indexOf("://");
+		const scheme = path.slice(0, sep).toLowerCase();
+		const rest = path.slice(sep + 3);
+		try {
+			// Decode first (idempotent), then encode — but preserve slashes
+			const decoded = decodeURIComponent(rest);
+			return `${scheme}://${decoded.split("/").map(encodeURIComponent).join("/")}`;
+		} catch {
+			return `${scheme}://${rest.split("/").map(encodeURIComponent).join("/")}`;
+		}
 	}
 
 	async nextTurn(runId) {
@@ -71,15 +56,15 @@ export default class KnownStore {
 			path: candidate,
 		});
 		if (!existing) return candidate;
-		return `${candidate}_${Date.now()}`;
+		return `${candidate}_${++this.#seq}`;
 	}
 
 	async slugPath(runId, scheme, content, summary) {
-		const source = summary ? summary.replace(/,\s*/g, "/") : content || "";
+		const source = summary || content || "";
 		const base = slugify(source);
 		const prefix = `${scheme}://`;
 
-		if (!base) return `${prefix}${Date.now()}`;
+		if (!base) return `${prefix}${++this.#seq}`;
 
 		const candidate = `${prefix}${base}`;
 		const existing = await this.#db.get_entry_body.get({
@@ -88,7 +73,7 @@ export default class KnownStore {
 		});
 		if (!existing) return candidate;
 
-		return `${prefix}${base}_${Date.now()}`;
+		return `${prefix}${base}_${++this.#seq}`;
 	}
 
 	async upsert(
@@ -106,22 +91,6 @@ export default class KnownStore {
 		} = {},
 	) {
 		const normalized = KnownStore.normalizePath(path);
-		let delta = 0;
-
-		if (
-			this.#budgetGuard &&
-			status < 400 &&
-			this.#isVisible(normalized, fidelity)
-		) {
-			const existing = await this.#db.get_entry_body.get({
-				run_id: runId,
-				path: normalized,
-			});
-			delta =
-				countTokens(body) - (existing?.body ? countTokens(existing.body) : 0);
-			this.#budgetGuard.check(delta, normalized);
-		}
-
 		await this.#db.upsert_known_entry.run({
 			run_id: runId,
 			loop_id: loopId,
@@ -135,8 +104,6 @@ export default class KnownStore {
 			updated_at: updatedAt,
 		});
 		this.#emitChanged(runId, normalized, "upsert");
-
-		if (delta > 0) this.#budgetGuard?.charge(delta);
 	}
 
 	async promote(runId, path, turn) {
@@ -202,21 +169,6 @@ export default class KnownStore {
 	}
 
 	async promoteByPattern(runId, path, body, turn) {
-		let cost = 0;
-		if (this.#budgetGuard) {
-			const entries = await this.#db.get_entries_by_pattern.all({
-				run_id: runId,
-				path,
-				body: KnownStore.#bodyPattern(body),
-				limit: null,
-				offset: null,
-			});
-			cost = entries
-				.filter((e) => e.fidelity === "archive" || e.fidelity === "index")
-				.reduce((sum, e) => sum + (e.tokens_full || 0), 0);
-			if (cost > 0) this.#budgetGuard.check(cost, path);
-		}
-
 		await this.#db.promote_by_pattern.run({
 			run_id: runId,
 			path,
@@ -224,8 +176,6 @@ export default class KnownStore {
 			turn,
 		});
 		this.#emitChanged(runId, path, "promote");
-
-		if (cost > 0) this.#budgetGuard?.charge(cost);
 	}
 
 	async demoteByPattern(runId, path, body) {
@@ -257,24 +207,6 @@ export default class KnownStore {
 	}
 
 	async updateBodyByPattern(runId, path, body, newBody) {
-		let delta = 0;
-		if (this.#budgetGuard) {
-			const entries = await this.#db.get_entries_by_pattern.all({
-				run_id: runId,
-				path,
-				body: KnownStore.#bodyPattern(body),
-				limit: null,
-				offset: null,
-			});
-			const visible = entries.filter((e) =>
-				this.#isVisible(e.path, e.fidelity),
-			);
-			const oldTotal = visible.reduce((sum, e) => sum + (e.tokens || 0), 0);
-			const newTokensPer = countTokens(newBody);
-			delta = newTokensPer * visible.length - oldTotal;
-			if (delta > 0) this.#budgetGuard.check(delta, path);
-		}
-
 		await this.#db.update_body_by_pattern.run({
 			run_id: runId,
 			path,
@@ -282,8 +214,6 @@ export default class KnownStore {
 			new_body: newBody,
 		});
 		this.#emitChanged(runId, path, "body");
-
-		if (delta > 0) this.#budgetGuard?.charge(delta);
 	}
 
 	async resolve(runId, path, status, body) {
@@ -297,6 +227,19 @@ export default class KnownStore {
 		this.#emitChanged(runId, normalized, "resolve");
 	}
 
+	async restoreSummarizedPrompts(runId) {
+		await this.#db.restore_summarized_prompts.run({ run_id: runId });
+		this.#emitChanged(runId, "prompt://batch", "fidelity");
+	}
+
+	async demotePreviousLoopLogging(runId, loopId) {
+		await this.#db.demote_previous_loop_logging.run({
+			run_id: runId,
+			loop_id: loopId,
+		});
+		this.#emitChanged(runId, "logging://batch", "fidelity");
+	}
+
 	async getLog(runId) {
 		return this.#db.get_results.all({ run_id: runId });
 	}