@possumtech/rummy 2.0.0 → 2.0.1

package/.env.example

@@ -36,6 +36,16 @@ RUMMY_RETENTION_DAYS=31
 # Timeouts (ms)
 RUMMY_RPC_TIMEOUT=30000
 RUMMY_FETCH_TIMEOUT=300000
+# Test harness — how long AuditClient waits for a single ask/act to reach
+# terminal status. Sized for full-context ingest on large-window models.
+RUMMY_TEST_RUN_TIMEOUT=3600000
+
+# LLM retry policy: time-bounded exponential backoff with full jitter.
+# DEADLINE is total wall-clock budget for an LLM call across all retries.
+# MAX_BACKOFF caps each inter-attempt sleep so a long deadline doesn't
+# yield 10-minute waits between attempts.
+RUMMY_LLM_DEADLINE_MS=600000
+RUMMY_LLM_MAX_BACKOFF_MS=30000
 
 # Debug
 # RUMMY_DEBUG=true
@@ -59,6 +69,17 @@ RUMMY_TOKEN_DIVISOR=2
 # LLM temperature (0 = deterministic, 0.7 = creative). Client can override per-request.
 RUMMY_TEMPERATURE=0.5
 
+# Run Attribute Defaults
+# Per-run attributes (passed in the run-creation set call) trump these.
+# Strict "1" enables; unset / "0" / "" disables. Useful in profile env
+# files (e.g. .env.tbench) layered via --env-file-if-exists.
+#
+# RUMMY_YOLO=1            # auto-accept every proposal (headless / CI / bench)
+# RUMMY_NO_INTERACTION=1  # exclude <ask_user> from the tool list
+# RUMMY_NO_WEB=1          # exclude <search> from the tool list
+# RUMMY_NO_PROPOSALS=1    # exclude <ask_user>/<env>/<sh>
+# RUMMY_NO_REPO=1         # skip rummy.repo scanning (file scan + overview)
+
 # Provider Configuration
 OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
 # OPENROUTER_API_KEY=

package/SPEC.md

@@ -524,6 +524,90 @@ Two mechanisms, operating at different layers:
    status 403 and emits `error://`. The tool remains advertised; the
    specific invocation is blocked.
 
+### YOLO Mode {#yolo_mode}
+
+When a run is started with the `yolo: true` attribute (parallel to
+`noRepo`/`noWeb`/`noInteraction`/`noProposals`), the server fully
+emulates a connected headless client: every proposal auto-accepts and
+every sh/env command spawns server-side, streaming output to the
+existing data-channel entries. No client involvement; no human
+approval required.
+
+**Plumbing.** The `yolo` attribute flows through the same path as
+`noProposals`: `set run://` → `attributes.yolo` → AgentLoop loop config
+JSON → RummyContext.yolo getter. The yolo plugin reads `rummy.yolo`
+off the proposal-pending event payload and engages only when set.
+
+**Behavior on yolo runs:**
+
+1. **Auto-accept every proposal.** The yolo plugin listens to
+   `proposal.pending`, replicates AgentLoop.resolve()'s accept path
+   inline (`proposal.accepting` filter for veto, `proposal.content`
+   filter for body, `entries.set state="resolved"`,
+   `proposal.accepted` event for plugin side effects). The
+   `entries.waitForResolution` blocking call wakes immediately; the
+   loop continues without RPC roundtrip.
+2. **Server-side sh/env execution.** For proposals on
+   `log://turn_N/sh/...` or `log://turn_N/env/...`, the yolo plugin
+   spawns the command in `projectRoot`, streams stdout/stderr to
+   `{dataBase}_1`/`{dataBase}_2` via `entries.set append=true`, and
+   transitions channels to terminal state on exit (200 / 500 mirror
+   of the existing `stream/completed` RPC contract). Done in-process,
+   no RPC roundtrip.
+3. **Non-yolo runs unaffected.** Without `yolo: true`, the plugin's
+   `proposal.pending` listener returns early. Existing client-driven
+   resolution (rummy.nvim, AuditClient's file-edit auto-accept) works
+   exactly as before.
+
+**Use cases.** E2E tests, benchmarks, CI, headless usage. The pattern
+is opt-in per run; rummy.nvim does not set `yolo: true` because
+human-in-the-loop control is the user-facing flow.
+
+**Architectural placement.** The yolo plugin owns its flag handling
+end-to-end — backbone files (TurnExecutor, AgentLoop) carry only the
+plumbing for the attribute and the rummy-context payload enrichment
+on `proposal.pending`. Feature logic stays in
+`src/plugins/yolo/yolo.js`.
+
+### Repo Overview {#repo_overview}
+
+The `rummy.repo` plugin maintains a single `repo://overview` entry per
+run, regenerated on every scan, that gives the model a navigable map
+of the project. It is the entry-point for code-aware runs — files
+themselves default to `archived` so a 5000-file repo doesn't dump
+hundreds of thousands of tokens into context before any work happens.
+
+**Entry contract.**
+
+- Path: `repo://overview` (scheme `repo`, category `data`,
+  `model_visible: 1`)
+- Visibility: `visible` (the navigation map is always in context)
+- Body: a markdown structure containing the project root, file count,
+  root-level files, top-level directories with file counts,
+  active/readonly constraints, and a navigation legend showing the
+  promote/demote idioms.
+- Visible projection: full body.
+- Summarized projection: first ~12 lines + a truncation marker, so a
+  model can demote it once it has the layout memorized.
+
+**File default visibility flip.**
+
+`FileScanner` registers each tracked file at `archived` by default
+(was `summarized`). Files with `constraint=active` still register at
+`visible`. The model uses `repo://overview` to discover paths, then
+promotes individual files via `<get path=...>` (visible, full body)
+or whole subtrees via `<set path=".../**" visibility="summarized"/>`
+(skim mode, symbols only).
+
+**Bounded cost.** The overview body is constant-ish in size regardless
+of repo size: root files capped, directory counts aggregated, no per-
+file symbol enumeration. The token cost in context stays roughly
+flat from a 30-file project to a 50,000-file monorepo.
+
+**Disabled when noRepo.** Setting `noRepo: true` on a run skips the
+scan entirely; no `repo://overview` is created and no file entries
+are registered. Behaviour identical to pre-plugin runs.
+
 ### Streaming Entries {#streaming_entries}
 
 Producers that generate output over time (shell commands, web fetches,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@possumtech/rummy",
-	"version": "2.0.0",
+	"version": "2.0.1",
 	"description": "Relational Unknowns Memory Management Yoke",
 	"keywords": [
 		"llm"
@@ -41,16 +41,16 @@
 		"test:intg": "node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test --test-concurrency=1 --test-force-exit --test $(find test/integration -name '*.test.js')",
 		"test:e2e": "mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test --test-concurrency=1 --test-force-exit --test-reporter=spec --test $(find test/e2e -name '*.test.js') 2>&1 | tee /tmp/rummy_test_diag/e2e_$(date +%Y%m%dT%H%M%S).log",
 		"test:live": "mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test --test-concurrency=1 --test-force-exit --test-reporter=spec --test $(find test/live -name '*.test.js') 2>&1 | tee /tmp/rummy_test_diag/live_$(date +%Y%m%dT%H%M%S).log",
-		"test:clean": "rm -rf test/lme/results test/mab/results test/tmp /tmp/rummy_test_diag /tmp/rummy_test_*.db /tmp/rummy_test_*.db-shm /tmp/rummy_test_*.db-wal && echo 'Test artifacts cleaned.'",
-		"test:mab:get": "node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test test/mab/download.js",
-		"test:mab": "bash -c 'mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test test/mab/runner.js \"$@\" 2>&1 | tee /tmp/rummy_test_diag/mab_$(date +%Y%m%dT%H%M%S).log' --",
-		"test:grok": "bash -c 'mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test --env-file-if-exists=.env.grok test/mab/runner.js \"$@\" 2>&1 | tee /tmp/rummy_test_diag/mab_grok_$(date +%Y%m%dT%H%M%S).log' --",
-		"test:mab:taxonomy": "bash -c 'mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test test/mab/runner.js --split Conflict_Resolution --row 0 --no-questions 2>&1 | tee /tmp/rummy_test_diag/taxonomy_$(date +%Y%m%dT%H%M%S).log' --",
-		"test:grok:taxonomy": "bash -c 'mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test --env-file-if-exists=.env.grok test/mab/runner.js --split Conflict_Resolution --row 0 --no-questions 2>&1 | tee /tmp/rummy_test_diag/taxonomy_grok_$(date +%Y%m%dT%H%M%S).log' --",
+		"test:clean": "rm -rf test/lme/results test/swe/results test/swe/repos test/tmp /tmp/rummy_test_diag /tmp/rummy_test_*.db /tmp/rummy_test_*.db-shm /tmp/rummy_test_*.db-wal && echo 'Test artifacts cleaned.'",
 		"test:lme:get": "node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test test/lme/download.js",
 		"test:lme": "bash -c 'mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test test/lme/runner.js \"$@\" 2>&1 | tee /tmp/rummy_test_diag/lme_$(date +%Y%m%dT%H%M%S).log' --",
-		"test:mab:clean": "rm -rf test/mab/results/*/",
+		"test:swe:setup": "bash test/swe/setup.sh",
+		"test:swe:get": "node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test test/swe/download.js",
+		"test:swe": "bash -c 'mkdir -p /tmp/rummy_test_diag && node --env-file-if-exists=.env.example --env-file-if-exists=.env --env-file-if-exists=.env.test test/swe/runner.js \"$@\" 2>&1 | tee /tmp/rummy_test_diag/swe_$(date +%Y%m%dT%H%M%S).log' --",
+		"test:swe:eval": "bash -c 'cd test/swe && source .venv/bin/activate && python evaluate.py \"$@\"' --",
+		"test:swe:baseline": "bash -c 'cd test/swe && source .venv/bin/activate && python baseline.py \"$@\"' --",
 		"test:lme:clean": "rm -rf test/lme/results/*/",
+		"test:swe:clean": "rm -rf test/swe/results/*/ test/swe/repos/",
 		"test:clear": "rm -rf /tmp/rummy_test_diag /tmp/rummy_test_*.db /tmp/rummy_test_*.db-shm /tmp/rummy_test_*.db-wal /tmp/rummy-stories-*",
 		"test:demo": "node --env-file-if-exists=.env.example --env-file-if-exists=.env bin/demo.js",
 		"test:spec": "node test/spec-coverage.js"

package/scriptify/ask_run.js

@@ -0,0 +1,77 @@
+/**
+ * Inject a follow-up question into an existing LME run and print the answer.
+ *
+ * Usage: node scriptify/ask_run.js <db_path> <run_alias> "your question"
+ *
+ * Reuses the run's full ingested context so the model answers with all
+ * its accumulated knowledge. Used as a debugging tool to interrogate
+ * the model's reasoning after a benchmark completes.
+ */
+import TestDb from "../test/helpers/TestDb.js";
+import TestServer from "../test/helpers/TestServer.js";
+import RpcClient from "../test/helpers/RpcClient.js";
+
+const [, , dbPath, alias, ...questionParts] = process.argv;
+const question = questionParts.join(" ");
+
+if (!dbPath || !alias || !question) {
+	console.error(
+		'Usage: node scriptify/ask_run.js <db_path> <run_alias> "your question"',
+	);
+	process.exit(1);
+}
+
+const tdb = await TestDb.createAt(dbPath);
+const tserver = await TestServer.start(tdb);
+const client = new RpcClient(tserver.url);
+await client.connect();
+await client.call("rummy/hello", {
+	name: "ask_run",
+	projectRoot: "/tmp/rummy-lme",
+});
+
+console.log(`Asking ${alias}: ${question}\n`);
+
+const TERMINAL = [200, 204, 413, 422, 499, 500];
+const startRes = await client.call("set", {
+	path: `run://${alias}`,
+	body: question,
+	attributes: {
+		model: "grok",
+		mode: "ask",
+		noRepo: true,
+		noInteraction: true,
+		noWeb: true,
+		noProposals: true,
+	},
+});
+
+const deadline = Date.now() + 600_000;
+while (Date.now() < deadline) {
+	const row = await tdb.db.get_run_by_alias.get({ alias });
+	if (TERMINAL.includes(row.status)) break;
+	await new Promise((r) => setTimeout(r, 500));
+}
+
+const runRow = await tdb.db.get_run_by_alias.get({ alias });
+const entries = await tdb.db.get_known_entries.all({ run_id: runRow.id });
+const reasoning = entries
+	.filter((e) => e.scheme === "reasoning")
+	.toSorted((a, b) => b.turn - a.turn)[0];
+const assistant = entries
+	.filter((e) => e.scheme === "assistant")
+	.toSorted((a, b) => b.turn - a.turn)[0];
+
+if (reasoning) {
+	console.log("=== REASONING ===");
+	console.log(reasoning.body);
+	console.log("");
+}
+if (assistant) {
+	console.log("=== ANSWER ===");
+	console.log(assistant.body);
+}
+
+await client.close();
+await tserver.stop();
+await tdb.cleanup();

package/src/agent/AgentLoop.js

@@ -81,19 +81,7 @@ export default class AgentLoop {
 		const runUsage = await this.#db.get_run_usage.get({ run_id: runId });
 		const history = await this.#entries.getLog(runId);
 		const unknowns = await this.#entries.getUnknowns(runId);
-		const latestSummary = history
-			.filter((e) => {
-				// Updates are under the unified log namespace at
-				// log://turn_N/update/<slug>. Match by path pattern rather
-				// than scheme (scheme is now "log" for all log entries).
-				if (!/^log:\/\/turn_\d+\/update\//.test(e.path)) return false;
-				const attrs =
-					typeof e.attributes === "string"
-						? JSON.parse(e.attributes)
-						: e.attributes;
-				return attrs?.status === 200;
-			})
-			.at(-1);
+		const latestSummary = this.#hooks.instructions.findLatestSummary(history);
 
 		// Always emit complete telemetry. When we don't have a fresh turn
 		// result (abort/max-turns/crash), read the last turn's context
@@ -287,10 +275,13 @@ export default class AgentLoop {
 		if (!project)
 			throw new Error(msg("error.project_not_found", { projectId }));
 
-		const noRepo = options?.noRepo === true;
-		const noInteraction = options?.noInteraction === true;
-		const noWeb = options?.noWeb === true;
-		const noProposals = options?.noProposals === true;
+		const noRepo = options?.noRepo ?? process.env.RUMMY_NO_REPO === "1";
+		const noInteraction =
+			options?.noInteraction ?? process.env.RUMMY_NO_INTERACTION === "1";
+		const noWeb = options?.noWeb ?? process.env.RUMMY_NO_WEB === "1";
+		const noProposals =
+			options?.noProposals ?? process.env.RUMMY_NO_PROPOSALS === "1";
+		const yolo = options?.yolo ?? process.env.RUMMY_YOLO === "1";
 		const requestedModel = model;
 
 		const runInfo = await this.ensureRun(
@@ -314,6 +305,7 @@ export default class AgentLoop {
 				noInteraction,
 				noWeb,
 				noProposals,
+				yolo,
 				temperature: options?.temperature,
 			}),
 		});
@@ -367,6 +359,7 @@ export default class AgentLoop {
 					noInteraction = false,
 					noWeb = false,
 					noProposals = false,
+					yolo = false,
 				} = loopConfig;
 
 				let result;
@@ -384,6 +377,7 @@ export default class AgentLoop {
 						noInteraction,
 						noWeb,
 						noProposals,
+						yolo,
 						options: { ...options, temperature: loopConfig.temperature },
 						hook,
 						signal: controller.signal,
@@ -448,6 +442,7 @@ export default class AgentLoop {
 		noInteraction,
 		noWeb,
 		noProposals,
+		yolo,
 		options,
 		hook,
 		signal,
@@ -534,6 +529,7 @@ export default class AgentLoop {
 					noWeb,
 					noInteraction,
 					noProposals,
+					yolo,
 					toolSet,
 					contextSize,
 					options: { ...options, isContinuation: loopIteration > 1 },
@@ -751,7 +747,7 @@ export default class AgentLoop {
 		return { run: runAlias, status: runRow.status };
 	}
 
-	async inject(runAlias, message, mode) {
+	async inject(runAlias, message, mode, options = {}) {
 		if (mode !== "ask" && mode !== "act") {
 			throw new Error(
 				`inject: mode is required and must be "ask" or "act" (got ${JSON.stringify(mode)})`,
@@ -761,6 +757,14 @@ export default class AgentLoop {
 		if (!runRow)
 			throw new Error(msg("error.run_not_found", { runId: runAlias }));
 
+		const noRepo = options?.noRepo ?? process.env.RUMMY_NO_REPO === "1";
+		const noInteraction =
+			options?.noInteraction ?? process.env.RUMMY_NO_INTERACTION === "1";
+		const noWeb = options?.noWeb ?? process.env.RUMMY_NO_WEB === "1";
+		const noProposals =
+			options?.noProposals ?? process.env.RUMMY_NO_PROPOSALS === "1";
+		const yolo = options?.yolo ?? process.env.RUMMY_YOLO === "1";
+
 		const nextTurn = runRow.next_turn;
 
 		await this.#entries.set({
@@ -784,7 +788,14 @@ export default class AgentLoop {
 			mode,
 			model: runRow.model,
 			prompt: message,
-			config: "{}",
+			config: JSON.stringify({
+				noRepo,
+				noInteraction,
+				noWeb,
+				noProposals,
+				yolo,
+				temperature: options?.temperature,
+			}),
 		});
 
 		const projectId = runRow.project_id;

package/src/agent/Entries.js

@@ -38,6 +38,7 @@ export default class Entries {
 	}
 
 	static scheme(path) {
+		if (!path) return null;
 		const idx = path.indexOf("://");
 		return idx > 0 ? path.slice(0, idx) : null;
 	}
@@ -474,7 +475,7 @@ export default class Entries {
 		runId,
 		path,
 		body = null,
-		{ limit = null, offset = null } = {},
+		{ limit = null, offset = null, includeAuditSchemes = false } = {},
 	) {
 		return this.#db.get_entries_by_pattern.all({
 			run_id: runId,
@@ -482,6 +483,7 @@ export default class Entries {
 			body: body ? body : null,
 			limit,
 			offset,
+			include_audit_schemes: includeAuditSchemes ? 1 : null,
 		});
 	}
 
@@ -494,7 +496,19 @@ export default class Entries {
 		}
 	}
 
-	waitForResolution(runId, path) {
+	async waitForResolution(runId, path) {
+		// Check current state first — if a synchronous in-process resolver
+		// (yolo) flipped the entry to terminal during proposal.pending,
+		// the state change has already happened and no future drain will
+		// fire. Without this guard, in-process resolvers would deadlock.
+		const current = await this.getState(runId, path);
+		if (
+			current &&
+			current.state !== "proposed" &&
+			current.state !== "streaming"
+		) {
+			return;
+		}
 		const normalized = Entries.normalizePath(path);
 		const key = `${runId}:${normalized}`;
 		return new Promise((resolve) => {
@@ -559,6 +573,13 @@ export default class Entries {
 		});
 	}
 
+	async archivePriorPromptArtifacts(runId, currentTurn) {
+		await this.#db.archive_prior_prompt_artifacts.run({
+			run_id: runId,
+			current_turn: currentTurn,
+		});
+	}
+
 	/**
 	 * Demote all promoted entries for a run on a given turn. Returns the
 	 * affected rows (path, tokens) so callers can summarize.

package/src/agent/ProjectAgent.js

@@ -83,8 +83,8 @@ export default class ProjectAgent {
 		return this.#agentLoop.resolve(run, resolution);
 	}
 
-	async inject(run, message, mode) {
-		return this.#agentLoop.inject(run, message, mode);
+	async inject(run, message, mode, options = {}) {
+		return this.#agentLoop.inject(run, message, mode, options);
 	}
 
 	// Synchronously create (or fork) a run row and return the alias.

package/src/agent/TurnExecutor.js

@@ -30,6 +30,7 @@ export default class TurnExecutor {
 		noWeb,
 		noInteraction,
 		noProposals,
+		yolo,
 		toolSet,
 		contextSize,
 		options,
@@ -70,6 +71,7 @@ export default class TurnExecutor {
 				noWeb,
 				noInteraction,
 				noProposals,
+				yolo,
 				toolSet,
 				contextSize,
 				systemPrompt: null,
@@ -332,6 +334,7 @@ export default class TurnExecutor {
 					projectId,
 					run: currentAlias,
 					proposed: [p],
+					rummy,
 				});
 				await this.#entries.waitForResolution(currentRunId, p.path);
 				const resolved = await this.#entries.getState(currentRunId, p.path);

package/src/agent/known_queries.sql

@@ -1,7 +1,7 @@
 -- PREP: get_known_entries
 SELECT
 	path, scheme, state, outcome, visibility, body, turn, hash
-	, attributes, countTokens(body) AS tokens, scope
+	, attributes, countTokens(body) AS tokens, scope, loop_id
 FROM known_entries
 WHERE run_id = :run_id
 ORDER BY path;

package/src/agent/known_store.sql

@@ -223,15 +223,20 @@ WHERE run_id = :run_id AND entry_id IN (
 );
 
 -- PREP: get_entries_by_pattern
+-- Default excludes audit schemes (system://, reasoning://, model://, user://,
+-- assistant://, content://, instructions://) so model-facing tools never leak
+-- internal entries. Internal callers that need them pass include_audit_schemes=1.
 SELECT
 	e.path, e.body, e.scheme, rv.state, rv.outcome, rv.visibility
 	, countTokens(e.body) AS tokens, e.attributes
 FROM run_views AS rv
 JOIN entries AS e ON e.id = rv.entry_id
+JOIN schemes AS s ON s.name = COALESCE(e.scheme, 'file')
 WHERE
 	rv.run_id = :run_id
 	AND hedmatch(:path, e.path)
 	AND (:body IS NULL OR hedsearch(:body, e.body))
+	AND (:include_audit_schemes IS NOT NULL OR s.model_visible = 1)
 ORDER BY e.path
 LIMIT
 	COALESCE(:limit, -1)

package/src/agent/materializeContext.js

@@ -1,5 +1,5 @@
 import ContextAssembler from "./ContextAssembler.js";
-import { countTokens } from "./tokens.js";
+import { countLines, countTokens } from "./tokens.js";
 
 /**
  * Rebuild turn_context from v_model_context, then assemble messages.
@@ -54,7 +54,8 @@ export default async function materializeContext({
 		});
 		const vTokens = countTokens(visibleProjection);
 		const sTokens = countTokens(summarizedProjection);
-		tokenAccounting.set(row.path, { vTokens, sTokens });
+		const vLines = countLines(visibleProjection);
+		tokenAccounting.set(row.path, { vTokens, sTokens, vLines });
 		const projectedBody =
 			row.visibility === "visible" ? visibleProjection : summarizedProjection;
 		await db.insert_turn_context.run({
@@ -79,6 +80,7 @@ export default async function materializeContext({
 		row.vTokens = t.vTokens;
 		row.sTokens = t.sTokens;
 		row.aTokens = t.vTokens - t.sTokens;
+		row.vLines = t.vLines;
 	}
 	const lastCtx = await db.get_last_context_tokens.get({ run_id: runId });
 	// First turn of a new run has no prior context.

package/src/agent/runs.sql

@@ -92,6 +92,25 @@ SELECT
 FROM run_views
 WHERE run_id = :parent_run_id;
 
+-- PREP: archive_prior_prompt_artifacts
+-- Multi-prompt sessions accumulate artifacts from prior prompt cycles
+-- (consumed prompts, their per-turn logs). These pollute the validator's
+-- prior-prompts check on subsequent Deployment landings. Archive all
+-- prior prompt:// entries and prior-turn log:// entries when a new
+-- prompt arrives. Knowns/unknowns/file entries are untouched — they
+-- carry persistent knowledge across cycles. The loop_id IS NULL clause
+-- catches forked-in views from a parent run (per fork_known_entries),
+-- which represent prior cycles' artifacts inherited into a clean child.
+UPDATE run_views
+SET visibility = 'archived'
+WHERE run_id = :run_id
+	AND visibility != 'archived'
+	AND (turn < :current_turn OR loop_id IS NULL)
+	AND entry_id IN (
+		SELECT id FROM entries
+		WHERE scheme IN ('prompt', 'log')
+	);
+
 -- PREP: get_active_runs
 SELECT r.id
 FROM runs AS r

package/src/agent/tokens.js

@@ -12,3 +12,9 @@ export function countTokens(text) {
 	if (!text) return 0;
 	return Math.ceil(text.length / DIVISOR);
 }
+
+export function countLines(text) {
+	if (!text) return 0;
+	const newlines = (text.match(/\n/g) || []).length;
+	return text.endsWith("\n") ? newlines : newlines + 1;
+}

package/src/hooks/RummyContext.js

@@ -106,6 +106,10 @@ export default class RummyContext {
 		return this.#context.noProposals === true;
 	}
 
+	get yolo() {
+		return this.#context.yolo === true;
+	}
+
 	get toolSet() {
 		return this.#context.toolSet;
 	}

package/src/llm/LlmProvider.js

@@ -4,8 +4,12 @@ import {
 	isContextExceededMessage,
 	isTransientMessage,
 } from "./errors.js";
+import { retryWithBackoff } from "./retry.js";
 
-const MAX_TRANSIENT_RETRIES = 3;
+const DEADLINE_MS = Number(process.env.RUMMY_LLM_DEADLINE_MS);
+const MAX_BACKOFF_MS = Number(process.env.RUMMY_LLM_MAX_BACKOFF_MS);
+if (!DEADLINE_MS) throw new Error("RUMMY_LLM_DEADLINE_MS must be set");
+if (!MAX_BACKOFF_MS) throw new Error("RUMMY_LLM_MAX_BACKOFF_MS must be set");
 
 /**
  * Thin dispatcher over the LLM provider registry (`hooks.llm.providers`).
@@ -55,27 +59,26 @@ export default class LlmProvider {
 			);
 		}
 
-		for (let attempt = 0; ; attempt++) {
-			try {
-				return await provider.completion(
-					messages,
-					resolvedModel,
-					resolvedOptions,
-				);
-			} catch (err) {
-				if (isContextExceededMessage(err.message)) {
-					throw new ContextExceededError(err.message, { cause: err });
-				}
-				if (
-					isTransientMessage(err.message) &&
-					attempt < MAX_TRANSIENT_RETRIES
-				) {
-					const delay = 1000 * 2 ** attempt;
-					await new Promise((r) => setTimeout(r, delay));
-					continue;
-				}
-				throw err;
+		try {
+			return await retryWithBackoff(
+				() => provider.completion(messages, resolvedModel, resolvedOptions),
+				{
+					signal: options.signal,
+					deadlineMs: DEADLINE_MS,
+					maxDelayMs: MAX_BACKOFF_MS,
+					isRetryable: (err) => isTransientMessage(err.message),
+					onRetry: (err, attempt, delayMs, remainingMs) => {
+						console.error(
+							`[LLM] transient failure on ${provider.name} attempt ${attempt}: ${err.message}; retrying in ${delayMs}ms (${Math.round(remainingMs / 1000)}s deadline remaining)`,
+						);
+					},
+				},
+			);
+		} catch (err) {
+			if (isContextExceededMessage(err.message)) {
+				throw new ContextExceededError(err.message, { cause: err });
 			}
+			throw err;
 		}
 	}
 

package/src/llm/errors.js

@@ -14,7 +14,7 @@ export function isContextExceededMessage(message) {
 }
 
 const TRANSIENT_PATTERN =
-	/\b(503|429|timeout|ECONNREFUSED|ECONNRESET|unavailable)\b/i;
+	/\b(500|502|503|504|429|timeout|TimeoutError|aborted|unavailable|ECONNREFUSED|ECONNRESET|ENOTFOUND|EHOSTUNREACH|ETIMEDOUT|EPIPE|ECONNABORTED|fetch failed)\b/i;
 
 export function isTransientMessage(message) {
 	return TRANSIENT_PATTERN.test(String(message));