@possumtech/rummy 2.0.1 → 2.1.0

package/migrations/001_initial_schema.sql

@@ -218,7 +218,8 @@ CREATE TABLE IF NOT EXISTS turn_context (
 		state IN ('proposed', 'streaming', 'resolved', 'failed', 'cancelled')
 	)
 	, outcome TEXT
-	, visibility TEXT NOT NULL CHECK (visibility IN ('visible', 'summarized'))
+	-- 'archived' permitted; see prompt plugin README for the exception.
+	, visibility TEXT NOT NULL CHECK (visibility IN ('visible', 'summarized', 'archived'))
 	, body TEXT NOT NULL DEFAULT ''
 	, attributes JSON NOT NULL DEFAULT '{}' CHECK (json_valid(attributes))
 	, category TEXT NOT NULL DEFAULT 'logging'

package/package.json

@@ -1,12 +1,13 @@
 {
 	"name": "@possumtech/rummy",
-	"version": "2.0.1",
+	"version": "2.1.0",
 	"description": "Relational Unknowns Memory Management Yoke",
 	"keywords": [
 		"llm"
 	],
 	"bin": {
-		"rummy": "./bin/rummy.js"
+		"rummy": "./bin/rummy.js",
+		"rummy-cli": "./src/plugins/cli/bin.js"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -51,6 +52,9 @@
 		"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:tbench:setup": "bash -c 'set -a; source .env.tbench; set +a; bash test/tbench/setup.sh'",
+		"test:tbench": "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.tbench test/tbench/runner.js \"$@\" 2>&1 | tee /tmp/rummy_test_diag/tbench_$(date +%Y%m%dT%H%M%S).log' --",
+		"test:tbench:clean": "rm -rf test/tbench/results/*/",
 		"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/cache_probe.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// Probe llama-server cache behavior. Send variations of the same request
+// and inspect cached_tokens in the response usage block to determine
+// whether caching is token-prefix or message-hash level.
+
+const URL = "http://127.0.0.1:11435/v1/chat/completions";
+const MODEL = "gemma-4-26B-A4B-it-UD-Q3_K_XL.gguf";
+
+async function probe(label, system, user) {
+	const body = {
+		model: MODEL,
+		messages: [
+			{ role: "system", content: system },
+			{ role: "user", content: user },
+		],
+		think: true,
+		temperature: 0.5,
+	};
+	const res = await fetch(URL, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+	});
+	const data = await res.json();
+	const u = data.usage || {};
+	const cached =
+		u.prompt_tokens_details?.cached_tokens ??
+		u.cached_tokens ??
+		0;
+	console.log(
+		`[${label}] prompt_tokens=${u.prompt_tokens ?? "?"} cached_tokens=${cached} system_chars=${system.length} user_chars=${user.length}`,
+	);
+}
+
+const STATIC_SYSTEM_BASE = `You are a helpful assistant.
+
+Tools available:
+- foo: does foo
+- bar: does bar
+- baz: does baz
+
+Always be concise.`;
+
+const ADDITION_A = "\n\n<context>\n<known path=\"k1\">first known fact</known>\n</context>";
+const ADDITION_B = "\n\n<context>\n<known path=\"k1\">first known fact</known>\n<known path=\"k2\">second known fact</known>\n</context>";
+const ADDITION_C = "\n\n<context>\n<known path=\"k2\">second known fact</known>\n<known path=\"k1\">first known fact</known>\n</context>";
+
+const USER_A = "Hello.";
+
+console.log("=== Run 1: baseline (cold, then immediate repeat) ===");
+await probe("1a baseline cold", STATIC_SYSTEM_BASE, USER_A);
+await probe("1b same-as-1a    ", STATIC_SYSTEM_BASE, USER_A);
+
+console.log("\n=== Run 2: same base, then base + appended context (prefix unchanged) ===");
+await probe("2a base only     ", STATIC_SYSTEM_BASE, USER_A);
+await probe("2b base + 1 entry", STATIC_SYSTEM_BASE + ADDITION_A, USER_A);
+await probe("2c base + 2 entries", STATIC_SYSTEM_BASE + ADDITION_B, USER_A);
+
+console.log("\n=== Run 3: prefix change (entries reordered, same body) ===");
+await probe("3a base + 2 entries (k1,k2)", STATIC_SYSTEM_BASE + ADDITION_B, USER_A);
+await probe("3b base + 2 entries (k2,k1) reordered", STATIC_SYSTEM_BASE + ADDITION_C, USER_A);
+
+console.log("\n=== Run 4: small mid-prefix change ===");
+const MIDDIFF = STATIC_SYSTEM_BASE.replace("baz", "qux");
+await probe("4a stable base   ", STATIC_SYSTEM_BASE, USER_A);
+await probe("4b changed baz→qux", MIDDIFF, USER_A);

package/scriptify/cache_probe_grok.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// Same probe as cache_probe.js but against OpenRouter's grok endpoint.
+// If cached_tokens behaves sanely (incremental matches preserve prefix),
+// then llama-server's behavior was the local anomaly.
+
+const URL = `${process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1"}/chat/completions`;
+const MODEL = "x-ai/grok-4.1-fast";
+
+if (!process.env.OPENROUTER_API_KEY) {
+	console.error("OPENROUTER_API_KEY required");
+	process.exit(1);
+}
+
+async function probe(label, system, user) {
+	const body = {
+		model: MODEL,
+		messages: [
+			{ role: "system", content: system },
+			{ role: "user", content: user },
+		],
+		include_reasoning: true,
+		temperature: 0.5,
+	};
+	const res = await fetch(URL, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
+		},
+		body: JSON.stringify(body),
+	});
+	const data = await res.json();
+	const u = data.usage || {};
+	const cached =
+		u.prompt_tokens_details?.cached_tokens ??
+		u.cached_tokens ??
+		u.cache_read_input_tokens ??
+		0;
+	console.log(
+		`[${label}] prompt_tokens=${u.prompt_tokens ?? "?"} cached_tokens=${cached} system_chars=${system.length}`,
+	);
+}
+
+const STATIC_SYSTEM_BASE = `You are a helpful assistant.
+
+Tools available:
+- foo: does foo
+- bar: does bar
+- baz: does baz
+
+Always be concise.`;
+
+const ADDITION_A = "\n\n<context>\n<known path=\"k1\">first known fact</known>\n</context>";
+const ADDITION_B = "\n\n<context>\n<known path=\"k1\">first known fact</known>\n<known path=\"k2\">second known fact</known>\n</context>";
+const ADDITION_C = "\n\n<context>\n<known path=\"k2\">second known fact</known>\n<known path=\"k1\">first known fact</known>\n</context>";
+
+const USER = "Hello.";
+
+console.log("=== Run 1: baseline (cold, then immediate repeat) ===");
+await probe("1a baseline cold", STATIC_SYSTEM_BASE, USER);
+await probe("1b same-as-1a   ", STATIC_SYSTEM_BASE, USER);
+
+console.log("\n=== Run 2: appended context (prefix unchanged) ===");
+await probe("2a base + 1     ", STATIC_SYSTEM_BASE + ADDITION_A, USER);
+await probe("2b base + 2     ", STATIC_SYSTEM_BASE + ADDITION_B, USER);
+
+console.log("\n=== Run 3: reordered (entries shuffled) ===");
+await probe("3a (k1,k2)      ", STATIC_SYSTEM_BASE + ADDITION_B, USER);
+await probe("3b (k2,k1)      ", STATIC_SYSTEM_BASE + ADDITION_C, USER);
+
+console.log("\n=== Run 4: mid-prefix character change ===");
+const MIDDIFF = STATIC_SYSTEM_BASE.replace("baz", "qux");
+await probe("4a stable base  ", STATIC_SYSTEM_BASE, USER);
+await probe("4b baz→qux      ", MIDDIFF, USER);

package/service.js

@@ -43,11 +43,7 @@ if (!rummyHome) {
 		}
 		for (const path of [homeExample, homeEnv]) {
 			if (!existsSync(path)) continue;
-			try {
-				process.loadEnvFile(path);
-			} catch (err) {
-				console.warn(`[RUMMY] Failed to load ${path}: ${err.message}`);
-			}
+			process.loadEnvFile(path);
 		}
 	}
 }
@@ -136,11 +132,21 @@ async function main() {
 		}
 	}
 
-	// 6b. Database Hygiene
+	// 6b. Database Hygiene — opt-in via RUMMY_RETENTION_DAYS.
 	const { statSync } = await import("node:fs");
-	try {
+	const retentionRaw = process.env.RUMMY_RETENTION_DAYS;
+	if (retentionRaw == null || retentionRaw === "") {
+		const dbSizeMB = (statSync(dbPath).size / 1024 / 1024).toFixed(2);
+		console.log(`[RUMMY] DB size: ${dbSizeMB}MB`);
+	} else {
+		const retentionDays = Number.parseInt(retentionRaw, 10);
+		if (!Number.isInteger(retentionDays) || retentionDays < 0) {
+			throw new Error(
+				`Invalid RUMMY_RETENTION_DAYS=${JSON.stringify(retentionRaw)} ` +
+					"(expected non-negative integer)",
+			);
+		}
 		const dbSizeBefore = statSync(dbPath).size;
-		const retentionDays = Number.parseInt(process.env.RUMMY_RETENTION_DAYS, 10);
 		await db.purge_old_runs.run({ retention_days: retentionDays });
 		const dbSizeAfter = statSync(dbPath).size;
 		const dbSizeMB = (dbSizeAfter / 1024 / 1024).toFixed(2);
@@ -153,8 +159,6 @@ async function main() {
 		if (dbSizeAfter > 100 * 1024 * 1024) {
 			console.warn(`[RUMMY] WARNING: Database exceeds 100MB. Consider manual cleanup.`);
 		}
-	} catch (err) {
-		console.warn(`[RUMMY] Hygiene skipped: ${err.message}`);
 	}
 
 	// 6b. Abort stuck runs (can't be running if the server just started)
@@ -164,8 +168,15 @@ async function main() {
 		console.log(`[RUMMY] Recovered ${aborted.changes} stuck run(s)`);
 	}
 
+	// 6c. Boot complete — DB open, plugins inited, models loaded,
+	// hygiene done. Plugins that need a one-shot post-boot action
+	// (e.g. the cli plugin firing a programmatic run) subscribe to
+	// this event. Fires BEFORE SocketServer so RPC clients can't
+	// race a one-shot run still being set up.
+	await hooks.boot.completed.emit({ db, hooks });
+
 	// 7. Start RPC Server
-	const port = Number.parseInt(process.env.PORT);
+	const port = Number.parseInt(process.env.RUMMY_PORT);
 	const server = new SocketServer(db, { port, hooks });
 
 	server.on("error", (err) => {

package/src/agent/AgentLoop.js

@@ -1,4 +1,3 @@
-import { computeBudget } from "./budget.js";
 import msg from "./messages.js";
 
 const HTTP_TO_RUN_STATE = {
@@ -31,20 +30,13 @@ export default class AgentLoop {
 		if (active) active.controller.abort();
 	}
 
-	/**
-	 * Abort every in-flight run and wait for each drain to settle.
-	 * Called from server close / client teardown so the process can
-	 * exit cleanly instead of leaving detached kickoff Promises
-	 * pinning the event loop.
-	 */
+	// Abort all in-flight runs and drain; rejections were already surfaced to original awaiters.
 	async abortAll() {
 		const promises = [];
 		for (const { controller, promise } of this.#activeRuns.values()) {
 			controller.abort();
 			promises.push(promise);
 		}
-		// allSettled: drain waits for every run to finish; rejections are
-		// already surfaced to whoever awaited the original run() call.
 		await Promise.allSettled(promises);
 	}
 
@@ -56,6 +48,24 @@ export default class AgentLoop {
 		return `Turn ${turn}/${maxTurns}`;
 	}
 
+	async #emitCompleted(hook, projectId, runId, out) {
+		const s = await this.#db.get_run_summary.get({ id: runId });
+		await hook.completed.emit({
+			projectId,
+			...out,
+			model: s.model,
+			turns: s.turns,
+			cost: s.cost,
+			tokens: {
+				prompt: s.prompt_tokens,
+				cached: s.cached_tokens,
+				completion: s.completion_tokens,
+				reasoning: s.reasoning_tokens,
+				total: s.total_tokens,
+			},
+		});
+	}
+
 	async #setRunStatus(runId, alias, httpStatus) {
 		await this.#db.update_run_status.run({ id: runId, status: httpStatus });
 		const state = HTTP_TO_RUN_STATE[httpStatus];
@@ -68,76 +78,6 @@ export default class AgentLoop {
 		});
 	}
 
-	async #emitRunState({
-		projectId,
-		runId,
-		alias,
-		turn,
-		status,
-		contextSize,
-		result = null,
-	}) {
-		if (!contextSize) throw new Error("#emitRunState: contextSize is required");
-		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 = 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
-		// tokens from the DB instead. Both code paths compute a real
-		// budget from real data — never undefined, never invented.
-		const rows = await this.#db.get_turn_context.all({
-			run_id: runId,
-			turn,
-		});
-		let totalTokens;
-		if (result) {
-			totalTokens = result.assembledTokens;
-		} else {
-			// No fresh turn result — this happens on abort/max-turns/crash
-			// emits that fire before any turn executed, or after a turn
-			// that never produced tokens. Read the last turn's assembled
-			// context_tokens from the DB; absent means no turn ran yet
-			// (zero is the truth, not a fallback).
-			const lastCtx = await this.#db.get_last_context_tokens.get({
-				run_id: runId,
-			});
-			totalTokens = lastCtx ? lastCtx.context_tokens : 0;
-		}
-		const budget = computeBudget({ rows, contextSize, totalTokens });
-
-		await this.#hooks.run.state.emit({
-			projectId,
-			run: alias,
-			turn,
-			status,
-			summary: latestSummary?.body,
-			history,
-			unknowns: unknowns.map((u) => ({ path: u.path, body: u.body })),
-			telemetry: {
-				modelAlias: result?.modelAlias,
-				model: result?.model,
-				temperature: result?.temperature,
-				context_size: contextSize,
-				context_tokens: totalTokens,
-				ceiling: budget.ceiling,
-				token_usage: budget.tokenUsage,
-				tokens_free: budget.tokensFree,
-				prompt_tokens: runUsage.prompt_tokens,
-				cached_tokens: runUsage.cached_tokens,
-				completion_tokens: runUsage.completion_tokens,
-				reasoning_tokens: runUsage.reasoning_tokens,
-				total_tokens: runUsage.total_tokens,
-				cost: runUsage.cost,
-				context_distribution: await this.#db.get_turn_distribution.all({
-					run_id: runId,
-					turn,
-				}),
-			},
-		});
-	}
-
 	async #writeRunEntry(
 		runId,
 		alias,
@@ -215,7 +155,6 @@ export default class AgentLoop {
 				const existing = this.#activeRuns.get(existingRun.id);
 				if (existing) existing.controller.abort();
 
-				// Clean up stale proposals from interrupted runs
 				const unresolved = await this.#entries.getUnresolved(existingRun.id);
 				for (const u of unresolved) {
 					await this.#entries.set({
@@ -228,7 +167,6 @@ export default class AgentLoop {
 				}
 				return { runId: existingRun.id, alias: existingRun.alias };
 			}
-			// Client-specified alias for a brand-new run — accept it verbatim.
 		}
 
 		const alias = run ? run : await this.#generateAlias(requestedModel);
@@ -314,8 +252,7 @@ export default class AgentLoop {
 			return { run: currentAlias, status: 100 };
 		}
 
-		// Allocate the controller + Promise pair here so `abortAll` can
-		// reach both — abort the controller, await the Promise's drain.
+		// Pair controller + Promise so abortAll can both signal and await drain.
 		const controller = new AbortController();
 		const promise = this.#drainQueue(
 			currentRunId,
@@ -465,7 +402,7 @@ export default class AgentLoop {
 		});
 
 		let loopIteration = 0;
-		const MAX_LOOP_ITERATIONS = Number(process.env.RUMMY_MAX_TURNS);
+		const MAX_LOOP_TURNS = Number(process.env.RUMMY_MAX_LOOP_TURNS);
 
 		await this.#hooks.loop.started.emit({
 			runId: currentRunId,
@@ -475,31 +412,23 @@ export default class AgentLoop {
 		});
 
 		try {
-			while (loopIteration < MAX_LOOP_ITERATIONS) {
+			while (loopIteration < MAX_LOOP_TURNS) {
 				if (signal.aborted) {
 					console.error(
 						`[LOOP] ${currentAlias} iter=${loopIteration} ABORT via signal`,
 					);
 					await this.#setRunStatus(currentRunId, currentAlias, 499);
-					await this.#emitRunState({
-						projectId,
-						runId: currentRunId,
-						alias: currentAlias,
-						turn: loopIteration,
-						status: 499,
-						contextSize,
-					});
 					const out = {
 						run: currentAlias,
 						status: 499,
 						turn: loopIteration,
 					};
-					await hook.completed.emit({ projectId, ...out });
+					await this.#emitCompleted(hook, projectId, currentRunId, out);
 					return out;
 				}
 				loopIteration++;
 				console.error(
-					`[LOOP] ${currentAlias} iter=${loopIteration} ENTER (max=${MAX_LOOP_ITERATIONS})`,
+					`[LOOP] ${currentAlias} iter=${loopIteration} ENTER (max=${MAX_LOOP_TURNS})`,
 				);
 
 				let turnPrompt;
@@ -508,7 +437,7 @@ export default class AgentLoop {
 				} else {
 					turnPrompt = this.#buildContinuationPrompt(
 						loopIteration,
-						MAX_LOOP_ITERATIONS,
+						MAX_LOOP_TURNS,
 					);
 				}
 
@@ -553,15 +482,6 @@ export default class AgentLoop {
 					`[LOOP] ${currentAlias} iter=${loopIteration} verdict: continue=${verdict.continue} status=${vStatus} reason=${vReason}`,
 				);
 
-				await this.#emitRunState({
-					projectId,
-					runId: currentRunId,
-					alias: currentAlias,
-					turn: result.turn,
-					status: verdict.continue ? 102 : verdict.status,
-					contextSize,
-					result,
-				});
 				await this.#hooks.run.step.completed.emit({
 					projectId,
 					run: currentAlias,
@@ -588,41 +508,24 @@ export default class AgentLoop {
 					turn: result.turn,
 					reason: verdict.reason,
 				};
-				await hook.completed.emit({ projectId, ...out });
+				await this.#emitCompleted(hook, projectId, currentRunId, out);
 				return out;
 			}
 
-			// MAX_TURNS exhaustion without a terminal update is abandonment.
 			console.error(
-				`[LOOP] ${currentAlias} hit MAX_LOOP_ITERATIONS=${MAX_LOOP_ITERATIONS} — abandoning at 499`,
+				`[LOOP] ${currentAlias} hit MAX_LOOP_TURNS=${MAX_LOOP_TURNS} — abandoning at 499`,
 			);
 			await this.#setRunStatus(currentRunId, currentAlias, 499);
-			await this.#emitRunState({
-				projectId,
-				runId: currentRunId,
-				alias: currentAlias,
-				turn: loopIteration,
-				status: 499,
-				contextSize,
-			});
 			const out = {
 				run: currentAlias,
 				status: 499,
 				turn: loopIteration,
 			};
-			await hook.completed.emit({ projectId, ...out });
+			await this.#emitCompleted(hook, projectId, currentRunId, out);
 			return out;
 		} catch (err) {
 			const status = signal.aborted ? 499 : 500;
 			await this.#setRunStatus(currentRunId, currentAlias, status);
-			await this.#emitRunState({
-				projectId,
-				runId: currentRunId,
-				alias: currentAlias,
-				turn: loopIteration,
-				status,
-				contextSize,
-			});
 			if (status === 500) {
 				await this.#hooks.error.log.emit({
 					store: this.#entries,
@@ -634,7 +537,7 @@ export default class AgentLoop {
 			}
 			const out = { run: currentAlias, status, turn: loopIteration };
 			if (status === 500) out.error = err.message;
-			await hook.completed.emit({ projectId, ...out });
+			await this.#emitCompleted(hook, projectId, currentRunId, out);
 			return out;
 		} finally {
 			await this.#hooks.loop.completed.emit({
@@ -674,11 +577,7 @@ export default class AgentLoop {
 				db: this.#db,
 				entries: this.#entries,
 			});
-			// Report the CURRENT run status (typically 102 mid-run) so the
-			// client's dispatch handler doesn't mistake a successful
-			// resolve's HTTP-style 200 ack for a terminal run status and
-			// prematurely close the document. Real terminal state comes
-			// from the run/state notification at end-of-turn.
+			// Return current run status (not 200) so client doesn't close on resolve ack.
 			return { run: runAlias, status: runRow.status };
 		}
 
@@ -698,8 +597,7 @@ export default class AgentLoop {
 			entries: this.#entries,
 		};
 
-		// Plugins veto acceptance (e.g. readonly) via proposal.accepting.
-		// First veto wins: state=failed with plugin-supplied outcome + body.
+		// First plugin veto wins via proposal.accepting (e.g. readonly).
 		if (action === "accept") {
 			const veto = await this.#hooks.proposal.accepting.filter(null, ctx);
 			if (veto?.allow === false) {
@@ -714,9 +612,7 @@ export default class AgentLoop {
 			}
 		}
 
-		// Compose the resolved body. Default is output || "". Plugins may
-		// override via proposal.content (e.g. set prefers the existing
-		// proposed body from the log entry).
+		// proposal.content override lets plugins prefer the proposed body (e.g. set).
 		const defaultBody = output ? output : "";
 		const resolvedBody = await this.#hooks.proposal.content.filter(
 			defaultBody,
@@ -741,9 +637,7 @@ export default class AgentLoop {
 				: this.#hooks.proposal.rejected;
 		await event.emit({ ...ctx, resolvedBody });
 
-		// Same rationale as the reject path: return current run status
-		// (102 mid-run) rather than a hardcoded 200 so the nvim client
-		// doesn't treat the RPC ack as a terminal signal.
+		// Return current run status (not 200) so client doesn't close on resolve ack.
 		return { run: runAlias, status: runRow.status };
 	}
 

package/src/agent/ContextAssembler.js

@@ -1,8 +1,4 @@
-/**
- * Thin orchestrator. Computes loopStartTurn from the rows,
- * then invokes assembly.system and assembly.user filter chains.
- * All rendering logic lives in plugins.
- */
+// Orchestrates assembly.system / assembly.user filter chains; plugins do all rendering.
 export default class ContextAssembler {
 	static async assembleFromTurnContext(
 		rows,
@@ -10,15 +6,13 @@ export default class ContextAssembler {
 			type = "ask",
 			systemPrompt = "",
 			contextSize = 0,
-			demoted = [],
 			toolSet = null,
 			lastContextTokens = 0,
 			turn = 1,
 		} = {},
 		hooks,
 	) {
-		// Find loop boundary from active prompt. Absent on turn 1 before
-		// the prompt plugin's turn.started handler has run.
+		// Loop boundary from active prompt; absent on turn 1 before prompt plugin's turn.started.
 		const promptEntry = rows.findLast(
 			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
@@ -31,7 +25,6 @@ export default class ContextAssembler {
 			type,
 			contextSize,
 			lastContextTokens,
-			demoted,
 			toolSet,
 			turn,
 		};