@possumtech/rummy 0.3.0 → 0.4.0

package/src/agent/KnownStore.js

@@ -1,25 +1,17 @@
 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;
+	#pendingResolutions = new Map();
 
 	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 +20,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 +31,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 +57,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 +74,7 @@ export default class KnownStore {
 		});
 		if (!existing) return candidate;
 
-		return `${prefix}${base}_${Date.now()}`;
+		return `${prefix}${base}_${++this.#seq}`;
 	}
 
 	async upsert(
@@ -106,22 +92,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 +105,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 +170,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 +177,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 +208,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 +215,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) {
@@ -295,8 +226,28 @@ export default class KnownStore {
 			body,
 		});
 		this.#emitChanged(runId, normalized, "resolve");
+		const key = `${runId}:${normalized}`;
+		const resolver = this.#pendingResolutions.get(key);
+		if (resolver) {
+			this.#pendingResolutions.delete(key);
+			resolver();
+		}
+	}
+
+	waitForResolution(runId, path) {
+		const normalized = KnownStore.normalizePath(path);
+		const key = `${runId}:${normalized}`;
+		return new Promise((resolve) => {
+			this.#pendingResolutions.set(key, resolve);
+		});
 	}
 
+	async restoreSummarizedPrompts(runId) {
+		await this.#db.restore_summarized_prompts.run({ run_id: runId });
+		this.#emitChanged(runId, "prompt://batch", "fidelity");
+	}
+
+
 	async getLog(runId) {
 		return this.#db.get_results.all({ run_id: runId });
 	}

package/src/agent/ResponseHealer.js

@@ -1,11 +1,55 @@
 const MAX_STALLS = Number(process.env.RUMMY_MAX_STALLS) || 3;
-const MAX_REPETITIONS = Number(process.env.RUMMY_MAX_REPETITIONS) || 3;
+const MIN_CYCLES = Number(process.env.RUMMY_MIN_CYCLES) || 3;
+const MAX_CYCLE_PERIOD = Number(process.env.RUMMY_MAX_CYCLE_PERIOD) || 4;
 const MAX_UPDATE_REPEATS = Number(process.env.RUMMY_MAX_UPDATE_REPEATS) || 3;
 
+/**
+ * Build a stable fingerprint for a single recorded entry.
+ * Uses scheme + original command target + all op-defining attributes.
+ * Excludes body (content too granular; same operation ≠ same content).
+ */
+function cmdFingerprint(entry) {
+	const attrs = { ...(entry.attributes ?? {}) };
+	delete attrs.body;
+	const target =
+		attrs.path ?? attrs.command ?? attrs.query ?? attrs.question ?? "";
+	delete attrs.path;
+	const extra = Object.keys(attrs)
+		.toSorted()
+		.filter((k) => attrs[k] != null)
+		.map((k) => `${k}=${attrs[k]}`)
+		.join(",");
+	return `${entry.scheme}:${target}${extra ? `[${extra}]` : ""}`;
+}
+
+/**
+ * Detect a repeating cycle in the fingerprint history.
+ * Checks periods 1..MAX_CYCLE_PERIOD for MIN_CYCLES consecutive repetitions.
+ * Catches AAAA (period 1), ABABAB (period 2), ABCABCABC (period 3), etc.
+ */
+function detectCycle(history) {
+	for (let k = 1; k <= MAX_CYCLE_PERIOD; k++) {
+		const needed = k * MIN_CYCLES;
+		if (history.length < needed) continue;
+		const tail = history.slice(-needed);
+		const cycle = tail.slice(0, k);
+		let match = true;
+		outer: for (let rep = 0; rep < MIN_CYCLES; rep++) {
+			for (let j = 0; j < k; j++) {
+				if (tail[rep * k + j] !== cycle[j]) {
+					match = false;
+					break outer;
+				}
+			}
+		}
+		if (match) return { detected: true, period: k, cycles: MIN_CYCLES };
+	}
+	return { detected: false };
+}
+
 export default class ResponseHealer {
 	#stallCount = 0;
-	#lastFingerprint = null;
-	#repetitionCount = 0;
+	#turnHistory = [];
 	#lastUpdateText = null;
 	#updateRepeatCount = 0;
 
@@ -52,38 +96,28 @@ export default class ResponseHealer {
 	}
 
 	/**
-	 * Check for repeated tool commands across turns.
+	 * Detect cyclic tool patterns across turns.
 	 * Returns { continue: boolean, reason?: string }
 	 *
-	 * Fingerprints the commands (name + path/query). If the same fingerprint
-	 * repeats for MAX_REPETITIONS consecutive turns, force-complete.
+	 * Appends this turn's fingerprint to history, then checks whether the
+	 * history ends in a repeating cycle of period 1..MAX_CYCLE_PERIOD with
+	 * at least MIN_CYCLES consecutive repetitions.
+	 *
+	 * Catches AAAA (period 1), ABABAB (period 2), ABCABC (period 3), etc.
+	 * Turns with no tool calls are skipped — they don't contribute to a cycle.
 	 */
 	assessRepetition({ actionCalls, writeCalls }) {
 		const commands = [...(actionCalls || []), ...(writeCalls || [])];
-		if (commands.length === 0) {
-			this.#lastFingerprint = null;
-			this.#repetitionCount = 0;
-			return { continue: true };
-		}
+		if (commands.length === 0) return { continue: true };
 
-		const fingerprint = commands
-			.map((c) => `${c.name}:${c.path || c.command || c.question || ""}`)
-			.toSorted()
-			.join("|");
-
-		if (fingerprint === this.#lastFingerprint) {
-			this.#repetitionCount++;
-			if (this.#repetitionCount >= MAX_REPETITIONS) {
-				const reason = `Same commands repeated ${this.#repetitionCount} turns`;
-				console.warn(`[RUMMY] Loop detected: ${reason}. Force-completing.`);
-				return { continue: false, reason };
-			}
-			console.warn(
-				`[RUMMY] Repeated commands (${this.#repetitionCount}/${MAX_REPETITIONS}): ${fingerprint.slice(0, 80)}`,
-			);
-		} else {
-			this.#repetitionCount = 1;
-			this.#lastFingerprint = fingerprint;
+		const fp = commands.map(cmdFingerprint).toSorted().join("|");
+		this.#turnHistory.push(fp);
+
+		const cycle = detectCycle(this.#turnHistory);
+		if (cycle.detected) {
+			const reason = `Cyclic tool pattern (period ${cycle.period}, ${cycle.cycles} repetitions)`;
+			console.warn(`[RUMMY] Loop detected: ${reason}. Force-completing.`);
+			return { continue: false, reason };
 		}
 
 		return { continue: true };
@@ -96,6 +130,7 @@ export default class ResponseHealer {
 	 *
 	 * Rules:
 	 *   <summarize/> present → done (terminate)
+	 *   <summarize/> + failed actions → overridden to <update> (continue)
 	 *   <update/> present  → continue (model says it's working)
 	 *   neither present    → warn, increment stall counter, continue
 	 *   stall counter hits MAX_STALLS → force-complete
@@ -146,8 +181,7 @@ export default class ResponseHealer {
 	 */
 	reset() {
 		this.#stallCount = 0;
-		this.#lastFingerprint = null;
-		this.#repetitionCount = 0;
+		this.#turnHistory = [];
 		this.#lastUpdateText = null;
 		this.#updateRepeatCount = 0;
 	}