@possumtech/rummy 0.2.8 → 0.3.1

package/src/agent/KnownStore.js

@@ -2,9 +2,25 @@ import slugify from "../sql/functions/slugify.js";
 
 export default class KnownStore {
 	#db;
+	#onChanged;
+	#schemes = new Map();
+	#seq = 0;
 
-	constructor(db) {
+	constructor(db, { onChanged } = {}) {
 		this.#db = db;
+		this.#onChanged = onChanged || null;
+	}
+
+	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);
+		}
+	}
+
+	#emitChanged(runId, path, changeType) {
+		if (this.#onChanged) this.#onChanged({ runId, path, changeType });
 	}
 
 	static scheme(path) {
@@ -14,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) {
@@ -30,21 +47,24 @@ 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()}`;
+		return `${candidate}_${++this.#seq}`;
 	}
 
-	async slugPath(runId, scheme, content) {
-		const base = slugify(content || "");
+	async slugPath(runId, scheme, content, summary) {
+		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({
@@ -53,7 +73,7 @@ export default class KnownStore {
 		});
 		if (!existing) return candidate;
 
-		return `${prefix}${base}_${Date.now()}`;
+		return `${prefix}${base}_${++this.#seq}`;
 	}
 
 	async upsert(
@@ -70,11 +90,12 @@ export default class KnownStore {
 			loopId = null,
 		} = {},
 	) {
+		const normalized = KnownStore.normalizePath(path);
 		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 +103,17 @@ export default class KnownStore {
 			attributes: attributes ? JSON.stringify(attributes) : null,
 			updated_at: updatedAt,
 		});
+		this.#emitChanged(runId, normalized, "upsert");
 	}
 
 	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 +125,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 +161,7 @@ export default class KnownStore {
 			run_id: runId,
 			pattern,
 		});
+		this.#emitChanged(runId, pattern, "remove");
 	}
 
 	static #bodyPattern(body) {
@@ -143,6 +175,7 @@ export default class KnownStore {
 			body: KnownStore.#bodyPattern(body),
 			turn,
 		});
+		this.#emitChanged(runId, path, "promote");
 	}
 
 	async demoteByPattern(runId, path, body) {
@@ -151,6 +184,7 @@ export default class KnownStore {
 			path,
 			body: KnownStore.#bodyPattern(body),
 		});
+		this.#emitChanged(runId, path, "demote");
 	}
 
 	async getEntriesByPattern(runId, path, body, { limit, offset } = {}) {
@@ -169,6 +203,7 @@ export default class KnownStore {
 			path,
 			body: KnownStore.#bodyPattern(body),
 		});
+		this.#emitChanged(runId, path, "remove");
 	}
 
 	async updateBodyByPattern(runId, path, body, newBody) {
@@ -178,21 +213,41 @@ export default class KnownStore {
 			body: KnownStore.#bodyPattern(body),
 			new_body: newBody,
 		});
+		this.#emitChanged(runId, path, "body");
 	}
 
 	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 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 });
 	}
 
+	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 +292,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,57 @@
 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;
 
 	/**
 	 * Heal a missing status tag. Called when the model emits
@@ -49,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 };
@@ -93,11 +130,12 @@ 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
 	 */
-	assessProgress({ summaryText, updateText, statusHealed }) {
+	assessProgress({ summaryText, updateText, statusHealed, flags }) {
 		if (summaryText) {
 			this.#stallCount = 0;
 			return { continue: false };
@@ -105,6 +143,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 };
 		}
 
@@ -128,7 +181,8 @@ export default class ResponseHealer {
 	 */
 	reset() {
 		this.#stallCount = 0;
-		this.#lastFingerprint = null;
-		this.#repetitionCount = 0;
+		this.#turnHistory = [];
+		this.#lastUpdateText = null;
+		this.#updateRepeatCount = 0;
 	}
 }