@possumtech/rummy 0.2.8 → 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,7 +118,9 @@ 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);
@@ -134,7 +142,12 @@ export default class AgentLoop {
 			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)) {
@@ -151,6 +164,8 @@ 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,
@@ -158,6 +173,13 @@ export default class AgentLoop {
 			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,
@@ -167,11 +189,64 @@ export default class AgentLoop {
 				currentLoopId: loop.id,
 				requestedModel: loop.model,
 				prompt: loop.prompt,
-				noContext: loopConfig.noContext || false,
+				noRepo: loopConfig.noRepo || false,
+				noInteraction: loopConfig.noInteraction || false,
+				noWeb: loopConfig.noWeb || false,
 				options: { ...options, temperature: loopConfig.temperature },
-				hook: loop.mode === "ask" ? this.#hooks.ask : this.#hooks.act,
+				hook,
 			});
 
+			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,
@@ -194,7 +269,9 @@ export default class AgentLoop {
 		currentLoopId,
 		requestedModel,
 		prompt,
-		noContext,
+		noRepo,
+		noInteraction,
+		noWeb,
 		options,
 		hook,
 	}) {
@@ -212,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();
@@ -219,6 +301,17 @@ 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) {
@@ -239,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,
@@ -255,12 +350,67 @@ export default class AgentLoop {
 					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,
 				});
@@ -409,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(() => {});
 		}
 	}
 
@@ -546,16 +704,9 @@ export default class AgentLoop {
 			runRow.id,
 			nextTurn,
 			`prompt://${nextTurn}`,
-			"",
-			200,
-			{ attributes: { mode: "ask" } },
-		);
-		await this.#knownStore.upsert(
-			runRow.id,
-			nextTurn,
-			`ask://${nextTurn}`,
 			message,
 			200,
+			{ attributes: { mode: "ask" } },
 		);
 
 		if (this.#activeRuns.has(runRow.id)) {

package/src/agent/ContextAssembler.js

@@ -6,17 +6,31 @@
 export default class ContextAssembler {
 	static async assembleFromTurnContext(
 		rows,
-		{ type = "ask", systemPrompt = "", contextSize = 0, demoted = [] } = {},
+		{
+			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, demoted };
+		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);

package/src/agent/KnownStore.js

@@ -1,10 +1,42 @@
 import slugify from "../sql/functions/slugify.js";
+import { countTokens } from "./tokens.js";
 
 export default class KnownStore {
 	#db;
+	#onChanged;
+	#budgetGuard = null;
+	#schemes = new Map();
 
-	constructor(db) {
+	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();
+		for (const row of rows) {
+			this.#schemes.set(row.name, row);
+		}
+	}
+
+	#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 });
 	}
 
 	static scheme(path) {
@@ -30,18 +62,21 @@ export default class KnownStore {
 		return row.turn;
 	}
 
-	async dedup(runId, scheme, target) {
-		const candidate = `${scheme}://${target}`;
+	async dedup(runId, scheme, target, turn) {
+		const encodedTarget = encodeURIComponent(target);
+		const turnPrefix = turn ? `turn_${turn}/` : "";
+		const candidate = `${scheme}://${turnPrefix}${encodedTarget}`;
 		const existing = await this.#db.get_entry_body.get({
 			run_id: runId,
-			path: KnownStore.normalizePath(candidate),
+			path: candidate,
 		});
 		if (!existing) return candidate;
 		return `${candidate}_${Date.now()}`;
 	}
 
-	async slugPath(runId, scheme, content) {
-		const base = slugify(content || "");
+	async slugPath(runId, scheme, content, summary) {
+		const source = summary ? summary.replace(/,\s*/g, "/") : content || "";
+		const base = slugify(source);
 		const prefix = `${scheme}://`;
 
 		if (!base) return `${prefix}${Date.now()}`;
@@ -70,11 +105,28 @@ export default class KnownStore {
 			loopId = null,
 		} = {},
 	) {
+		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,
 			turn,
-			path: KnownStore.normalizePath(path),
+			path: normalized,
 			body,
 			status,
 			fidelity,
@@ -82,14 +134,19 @@ export default class KnownStore {
 			attributes: attributes ? JSON.stringify(attributes) : null,
 			updated_at: updatedAt,
 		});
+		this.#emitChanged(runId, normalized, "upsert");
+
+		if (delta > 0) this.#budgetGuard?.charge(delta);
 	}
 
 	async promote(runId, path, turn) {
+		const normalized = KnownStore.normalizePath(path);
 		await this.#db.promote_path.run({
 			run_id: runId,
-			path: KnownStore.normalizePath(path),
+			path: normalized,
 			turn,
 		});
+		this.#emitChanged(runId, normalized, "promote");
 	}
 
 	async setFileFidelity(runId, pattern, fidelity) {
@@ -101,28 +158,35 @@ export default class KnownStore {
 		if (result.changes === 0) {
 			await this.upsert(runId, 0, pattern, "", 200, { fidelity });
 		}
+		this.#emitChanged(runId, pattern, "fidelity");
 	}
 
 	async setFidelity(runId, path, fidelity) {
+		const normalized = KnownStore.normalizePath(path);
 		await this.#db.set_fidelity.run({
 			run_id: runId,
-			path: KnownStore.normalizePath(path),
+			path: normalized,
 			fidelity,
 		});
+		this.#emitChanged(runId, normalized, "fidelity");
 	}
 
 	async demote(runId, path) {
+		const normalized = KnownStore.normalizePath(path);
 		await this.#db.demote_path.run({
 			run_id: runId,
-			path: KnownStore.normalizePath(path),
+			path: normalized,
 		});
+		this.#emitChanged(runId, normalized, "demote");
 	}
 
 	async remove(runId, path) {
+		const normalized = KnownStore.normalizePath(path);
 		await this.#db.delete_known_entry.run({
 			run_id: runId,
-			path: KnownStore.normalizePath(path),
+			path: normalized,
 		});
+		this.#emitChanged(runId, normalized, "remove");
 	}
 
 	async removeFilesByPattern(runId, pattern) {
@@ -130,6 +194,7 @@ export default class KnownStore {
 			run_id: runId,
 			pattern,
 		});
+		this.#emitChanged(runId, pattern, "remove");
 	}
 
 	static #bodyPattern(body) {
@@ -137,12 +202,30 @@ 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,
 			body: KnownStore.#bodyPattern(body),
 			turn,
 		});
+		this.#emitChanged(runId, path, "promote");
+
+		if (cost > 0) this.#budgetGuard?.charge(cost);
 	}
 
 	async demoteByPattern(runId, path, body) {
@@ -151,6 +234,7 @@ export default class KnownStore {
 			path,
 			body: KnownStore.#bodyPattern(body),
 		});
+		this.#emitChanged(runId, path, "demote");
 	}
 
 	async getEntriesByPattern(runId, path, body, { limit, offset } = {}) {
@@ -169,30 +253,58 @@ export default class KnownStore {
 			path,
 			body: KnownStore.#bodyPattern(body),
 		});
+		this.#emitChanged(runId, path, "remove");
 	}
 
 	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,
 			body: KnownStore.#bodyPattern(body),
 			new_body: newBody,
 		});
+		this.#emitChanged(runId, path, "body");
+
+		if (delta > 0) this.#budgetGuard?.charge(delta);
 	}
 
 	async resolve(runId, path, status, body) {
+		const normalized = KnownStore.normalizePath(path);
 		await this.#db.resolve_known_entry.run({
 			run_id: runId,
-			path: KnownStore.normalizePath(path),
+			path: normalized,
 			status,
 			body,
 		});
+		this.#emitChanged(runId, normalized, "resolve");
 	}
 
 	async getLog(runId) {
 		return this.#db.get_results.all({ run_id: runId });
 	}
 
+	async getEntries(runId) {
+		return this.#db.get_known_entries.all({ run_id: runId });
+	}
+
 	async getFileEntries(runId) {
 		return this.#db.get_file_entries.all({ run_id: runId });
 	}
@@ -237,11 +349,13 @@ export default class KnownStore {
 	}
 
 	async setAttributes(runId, path, attrs) {
+		const normalized = KnownStore.normalizePath(path);
 		await this.#db.update_entry_attributes.run({
 			run_id: runId,
-			path: KnownStore.normalizePath(path),
+			path: normalized,
 			attributes: JSON.stringify(attrs),
 		});
+		this.#emitChanged(runId, normalized, "attributes");
 	}
 
 	async getState(runId, path) {

package/src/agent/ProjectAgent.js

@@ -14,7 +14,10 @@ export default class ProjectAgent {
 		this.#db = db;
 		this.#hooks = hooks;
 		this.#llm = new LlmProvider(db);
-		this.#knownStore = new KnownStore(db);
+		this.#knownStore = new KnownStore(db, {
+			onChanged: (event) => hooks.entry.changed.emit(event).catch(() => {}),
+		});
+		this.#knownStore.loadSchemes(db);
 
 		const turnExecutor = new TurnExecutor(
 			db,

package/src/agent/ResponseHealer.js

@@ -1,10 +1,13 @@
 const MAX_STALLS = Number(process.env.RUMMY_MAX_STALLS) || 3;
 const MAX_REPETITIONS = Number(process.env.RUMMY_MAX_REPETITIONS) || 3;
+const MAX_UPDATE_REPEATS = Number(process.env.RUMMY_MAX_UPDATE_REPEATS) || 3;
 
 export default class ResponseHealer {
 	#stallCount = 0;
 	#lastFingerprint = null;
 	#repetitionCount = 0;
+	#lastUpdateText = null;
+	#updateRepeatCount = 0;
 
 	/**
 	 * Heal a missing status tag. Called when the model emits
@@ -97,7 +100,7 @@ export default class ResponseHealer {
 	 *   neither present    → warn, increment stall counter, continue
 	 *   stall counter hits MAX_STALLS → force-complete
 	 */
-	assessProgress({ summaryText, updateText, statusHealed }) {
+	assessProgress({ summaryText, updateText, statusHealed, flags }) {
 		if (summaryText) {
 			this.#stallCount = 0;
 			return { continue: false };
@@ -105,6 +108,21 @@ export default class ResponseHealer {
 
 		if (updateText && !statusHealed) {
 			this.#stallCount = 0;
+			// Track repeated update text — model stuck declaring readiness
+			// But if the model created new entries this turn, it's making
+			// progress even if the update text is the same.
+			const madeProgress = flags?.hasWrites || flags?.hasReads;
+			if (updateText === this.#lastUpdateText && !madeProgress) {
+				this.#updateRepeatCount++;
+				if (this.#updateRepeatCount >= MAX_UPDATE_REPEATS) {
+					const reason = `Same <update/> repeated ${this.#updateRepeatCount} turns: "${updateText.slice(0, 60)}"`;
+					console.warn(`[RUMMY] Stalled: ${reason}. Force-completing.`);
+					return { continue: false, reason };
+				}
+			} else {
+				this.#lastUpdateText = updateText;
+				this.#updateRepeatCount = 1;
+			}
 			return { continue: true };
 		}
 
@@ -130,5 +148,7 @@ export default class ResponseHealer {
 		this.#stallCount = 0;
 		this.#lastFingerprint = null;
 		this.#repetitionCount = 0;
+		this.#lastUpdateText = null;
+		this.#updateRepeatCount = 0;
 	}
 }