@possumtech/rummy 0.3.1 → 0.5.0

package/src/agent/ContextAssembler.js

@@ -14,6 +14,7 @@ export default class ContextAssembler {
 			toolSet = null,
 			lastContextTokens = 0,
 			turn = 1,
+			baselineTokens = 0,
 		} = {},
 		hooks,
 	) {
@@ -32,6 +33,7 @@ export default class ContextAssembler {
 			demoted,
 			toolSet,
 			turn,
+			baselineTokens,
 		};
 
 		const system = await hooks.assembly.system.filter(systemPrompt, ctx);

package/src/agent/KnownStore.js

@@ -5,6 +5,7 @@ export default class KnownStore {
 	#onChanged;
 	#schemes = new Map();
 	#seq = 0;
+	#pendingResolutions = new Map();
 
 	constructor(db, { onChanged } = {}) {
 		this.#db = db;
@@ -83,7 +84,7 @@ export default class KnownStore {
 		body,
 		status,
 		{
-			fidelity = "full",
+			fidelity = "promoted",
 			attributes = null,
 			hash = null,
 			updatedAt = null,
@@ -225,6 +226,20 @@ 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) {
@@ -232,14 +247,6 @@ export default class KnownStore {
 		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 });
 	}

package/src/agent/ResponseHealer.js

@@ -2,6 +2,8 @@ const MAX_STALLS = Number(process.env.RUMMY_MAX_STALLS) || 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;
+const MAX_PATH_STAGNATION =
+	Number(process.env.RUMMY_MAX_PATH_STAGNATION) || 5;
 
 /**
  * Build a stable fingerprint for a single recorded entry.
@@ -47,11 +49,28 @@ function detectCycle(history) {
 	return { detected: false };
 }
 
+/**
+ * Extract the target paths a command touches for stagnation detection.
+ * Same target logic as cmdFingerprint but returns the raw path for set
+ * comparison across turns.
+ */
+function cmdPaths(entry) {
+	const attrs = entry.attributes ?? {};
+	const paths = [];
+	if (attrs.path) paths.push(attrs.path);
+	if (attrs.to) paths.push(attrs.to);
+	if (attrs.command) paths.push(attrs.command);
+	if (attrs.query) paths.push(attrs.query);
+	if (attrs.question) paths.push(attrs.question);
+	return paths;
+}
+
 export default class ResponseHealer {
 	#stallCount = 0;
 	#turnHistory = [];
 	#lastUpdateText = null;
 	#updateRepeatCount = 0;
+	#pathRuns = new Map(); // path → consecutive turns touched
 
 	/**
 	 * Heal a missing status tag. Called when the model emits
@@ -67,8 +86,15 @@ export default class ResponseHealer {
 	static healStatus(content, commands) {
 		const trimmed = content.trim();
 
+		// Detect malformed-glitch content — model attempted a tool invocation
+		// (native call, malformed XML, etc.) that the parser couldn't dispatch.
+		// This is NOT an answer; it's a glitch that deserves the 3-strikes
+		// stall path so the model can recover. Without this check, the model
+		// emits one malformed call and the run terminates after a single turn.
+		const looksGlitched = /<\|tool_call>|<tool_call\|>/.test(trimmed);
+
 		// No commands + plain text = answered. Treat as summary.
-		if (commands.length === 0 && trimmed) {
+		if (commands.length === 0 && trimmed && !looksGlitched) {
 			console.warn("[RUMMY] Healed: plain text response treated as summary");
 			return { summaryText: trimmed.slice(0, 500), updateText: null };
 		}
@@ -120,6 +146,32 @@ export default class ResponseHealer {
 			return { continue: false, reason };
 		}
 
+		// Distinct-paths stagnation: the model might vary commands turn-to-turn
+		// (avoiding exact-cycle detection) but still churn on a single path.
+		// Track per-path consecutive touches; flag if any path is touched in
+		// MAX_PATH_STAGNATION consecutive turns. Catches semantic stagnation
+		// where the fingerprints differ in micro-detail but the work is stuck
+		// on one entry (e.g. endlessly re-setting/re-getting the same plan).
+		const touchedPaths = new Set();
+		for (const cmd of commands) {
+			for (const p of cmdPaths(cmd)) touchedPaths.add(p);
+		}
+		// Paths not touched this turn — run broken, remove from map.
+		for (const path of [...this.#pathRuns.keys()]) {
+			if (!touchedPaths.has(path)) this.#pathRuns.delete(path);
+		}
+		// Paths touched this turn — increment run.
+		for (const path of touchedPaths) {
+			this.#pathRuns.set(path, (this.#pathRuns.get(path) || 0) + 1);
+		}
+		for (const [path, run] of this.#pathRuns) {
+			if (run >= MAX_PATH_STAGNATION) {
+				const reason = `Path stagnation: ${path} touched ${run} consecutive turns`;
+				console.warn(`[RUMMY] ${reason}. Force-completing.`);
+				return { continue: false, reason };
+			}
+		}
+
 		return { continue: true };
 	}
 
@@ -184,5 +236,6 @@ export default class ResponseHealer {
 		this.#turnHistory = [];
 		this.#lastUpdateText = null;
 		this.#updateRepeatCount = 0;
+		this.#pathRuns = new Map();
 	}
 }