@possumtech/rummy 0.3.0 → 0.4.0

package/src/agent/XmlParser.js

@@ -4,7 +4,7 @@ import { normalizeAttrs, parseJsonEdit } from "../plugins/hedberg/normalize.js";
 import { parseSed } from "../plugins/hedberg/sed.js";
 
 const STORE_TOOLS = new Set(["get", "rm", "set", "mv", "cp", "search"]);
-const ALL_TOOLS = new Set([
+export const ALL_TOOLS = new Set([
 	...STORE_TOOLS,
 	"known",
 	"sh",
@@ -13,6 +13,7 @@ const ALL_TOOLS = new Set([
 	"summarize",
 	"update",
 	"unknown",
+	"think",
 ]);
 
 /**
@@ -100,7 +101,7 @@ function resolveCommand(name, attrs, rawBody) {
 	if (name === "known") {
 		const body = trimmed || a.body || "";
 		const path = a.path || null;
-		return { name, path, body };
+		return { name, ...a, path, body };
 	}
 
 	if (name === "get" || name === "rm") {
@@ -142,6 +143,8 @@ export default class XmlParser {
 	 * @param {string} content - Raw model response text
 	 * @returns {{ commands: Array, warnings: string[], unparsed: string }}
 	 */
+	static MAX_COMMANDS = Number(process.env.RUMMY_MAX_COMMANDS) || 99;
+
 	static parse(content) {
 		if (!content) return { commands: [], warnings: [], unparsed: "" };
 
@@ -153,13 +156,20 @@ export default class XmlParser {
 		const textChunks = [];
 		let current = null;
 		let ended = false;
+		let capped = false;
 
 		const parser = new Parser(
 			{
 				onopentag(name, attrs) {
+					if (capped) return;
 					if (!ALL_TOOLS.has(name)) {
 						if (current) {
-							current.rawBody += `<${name}>`;
+							const attrStr = Object.entries(attrs)
+								.map(([k, v]) => v === "" ? k : `${k}="${v}"`)
+								.join(" ");
+							current.rawBody += attrStr
+								? `<${name} ${attrStr}>`
+								: `<${name}>`;
 						}
 						return;
 					}
@@ -174,10 +184,17 @@ export default class XmlParser {
 						);
 					}
 
+					if (commands.length >= XmlParser.MAX_COMMANDS) {
+						capped = true;
+						current = null;
+						return;
+					}
+
 					current = { name, attrs, rawBody: "" };
 				},
 
 				ontext(text) {
+					if (capped) return;
 					if (current) {
 						current.rawBody += text;
 					} else {
@@ -186,6 +203,7 @@ export default class XmlParser {
 				},
 
 				onclosetag(name, isImplied) {
+					if (capped) return;
 					if (current && name === current.name) {
 						if (ended) {
 							warnings.push(`Unclosed <${name}> tag — content captured anyway`);
@@ -227,7 +245,7 @@ export default class XmlParser {
 		parser.end();
 
 		// Flush any unclosed tool tag
-		if (current) {
+		if (current && !capped) {
 			warnings.push(`Unclosed <${current.name}> tag — content captured anyway`);
 			commands.push(
 				resolveCommand(current.name, current.attrs, current.rawBody),
@@ -235,6 +253,12 @@ export default class XmlParser {
 			current = null;
 		}
 
+		if (capped) {
+			warnings.push(
+				`Tool call limit (${XmlParser.MAX_COMMANDS}) reached — remaining commands dropped`,
+			);
+		}
+
 		const unparsed = textChunks.join("").trim();
 		return { commands, warnings, unparsed };
 	}

package/src/agent/known_queries.sql

@@ -1,5 +1,5 @@
 -- PREP: get_known_entries
-SELECT path, scheme, status, fidelity, body, turn, hash, attributes
+SELECT path, scheme, status, fidelity, body, turn, hash, attributes, tokens
 FROM known_entries
 WHERE run_id = :run_id
 ORDER BY path;

package/src/agent/known_store.sql

@@ -1,13 +1,12 @@
 -- PREP: upsert_known_entry
 INSERT INTO known_entries (
 	run_id, loop_id, turn, path, body, status, fidelity, hash
-	, attributes, tokens, tokens_full, updated_at
+	, attributes, tokens, updated_at
 )
 VALUES (
 	:run_id, :loop_id, :turn, :path, :body, :status, :fidelity, :hash
 	, COALESCE(:attributes, '{}')
 	, countTokens(:body)
-	, countTokens(:body)
 	, COALESCE(:updated_at, CURRENT_TIMESTAMP)
 )
 ON CONFLICT (run_id, path) DO UPDATE SET
@@ -19,13 +18,12 @@ ON CONFLICT (run_id, path) DO UPDATE SET
 	, loop_id = excluded.loop_id
 	, turn = excluded.turn
 	, tokens = countTokens(excluded.body)
-	, tokens_full = countTokens(excluded.body)
 	, write_count = known_entries.write_count + 1
 	, updated_at = COALESCE(excluded.updated_at, CURRENT_TIMESTAMP);
 
 -- PREP: recount_tokens
 UPDATE known_entries
-SET tokens = :tokens, tokens_full = :tokens
+SET tokens = :tokens
 WHERE run_id = :run_id AND path = :path;
 
 -- PREP: get_stale_tokens
@@ -55,18 +53,6 @@ WHERE run_id = :run_id AND path = :path;
 UPDATE known_entries
 SET
 	fidelity = :fidelity
-	, tokens = CASE
-		WHEN :fidelity = 'archive'
-			THEN 0
-		WHEN :fidelity = 'index'
-			THEN 0
-		WHEN :fidelity = 'summary'
-			THEN COALESCE(
-				countTokens(json_extract(attributes, '$.summary')),
-				countTokens(substr(body, 1, 80))
-			)
-		ELSE tokens_full
-	END
 	, updated_at = CURRENT_TIMESTAMP
 WHERE run_id = :run_id AND hedmatch(:pattern, path) AND scheme IS NULL;
 
@@ -74,8 +60,8 @@ WHERE run_id = :run_id AND hedmatch(:pattern, path) AND scheme IS NULL;
 UPDATE known_entries
 SET
 	fidelity = 'full'
+	, status = 200
 	, turn = :turn
-	, tokens = tokens_full
 	, updated_at = CURRENT_TIMESTAMP
 WHERE run_id = :run_id AND path = :path;
 
@@ -83,26 +69,14 @@ WHERE run_id = :run_id AND path = :path;
 UPDATE known_entries
 SET
 	fidelity = 'archive'
-	, tokens = 0
 	, updated_at = CURRENT_TIMESTAMP
 WHERE run_id = :run_id AND path = :path;
 
 -- PREP: set_fidelity
+-- Tokens unchanged — always reflects full body cost.
 UPDATE known_entries
 SET
 	fidelity = :fidelity
-	, tokens = CASE
-		WHEN :fidelity = 'archive'
-			THEN 0
-		WHEN :fidelity = 'index'
-			THEN 0
-		WHEN :fidelity = 'summary'
-			THEN COALESCE(
-				countTokens(json_extract(attributes, '$.summary')),
-				countTokens(substr(body, 1, 80))
-			)
-		ELSE countTokens(body)
-	END
 	, updated_at = CURRENT_TIMESTAMP
 WHERE run_id = :run_id AND path = :path;
 
@@ -138,8 +112,8 @@ WHERE run_id = :run_id AND path = :path;
 UPDATE known_entries
 SET
 	fidelity = 'full'
+	, status = 200
 	, turn = :turn
-	, tokens = tokens_full
 	, updated_at = CURRENT_TIMESTAMP
 WHERE
 	run_id = :run_id
@@ -150,7 +124,6 @@ WHERE
 UPDATE known_entries
 SET
 	fidelity = 'archive'
-	, tokens = 0
 	, updated_at = CURRENT_TIMESTAMP
 WHERE
 	run_id = :run_id
@@ -158,7 +131,7 @@ WHERE
 	AND (:body IS NULL OR hedsearch(:body, body));
 
 -- PREP: get_entries_by_pattern
-SELECT path, body, scheme, status, fidelity, tokens_full, attributes
+SELECT path, body, scheme, status, fidelity, tokens, attributes
 FROM known_entries
 WHERE
 	run_id = :run_id
@@ -182,10 +155,35 @@ UPDATE known_entries
 SET
 	body = :new_body
 	, tokens = countTokens(:new_body)
-	, tokens_full = countTokens(:new_body)
 	, write_count = write_count + 1
 	, updated_at = CURRENT_TIMESTAMP
 WHERE
 	run_id = :run_id
 	AND hedmatch(:path, path)
 	AND (:body IS NULL OR hedsearch(:body, body));
+
+-- PREP: restore_summarized_prompts
+-- Restore prompt entries demoted to summary by a recovery phase that was
+-- interrupted (e.g. server crash). Safe to call unconditionally at loop
+-- start: if the full prompt would overflow, Prompt Demotion handles it.
+UPDATE known_entries
+SET
+	fidelity = 'full'
+	, updated_at = CURRENT_TIMESTAMP
+WHERE run_id = :run_id AND scheme = 'prompt' AND fidelity = 'summary';
+
+-- PREP: demote_turn_entries
+-- Demote all full entries from a turn to summary with 413 status.
+-- Tokens unchanged — always reports full cost regardless of fidelity.
+UPDATE known_entries
+SET
+	fidelity = 'summary'
+	, status = 413
+	, updated_at = CURRENT_TIMESTAMP
+WHERE
+	run_id = :run_id
+	AND turn = :turn
+	AND fidelity = 'full'
+	AND status < 400
+RETURNING path, tokens;
+

package/src/agent/runs.sql

@@ -81,11 +81,11 @@ RETURNING next_turn - 1 AS turn;
 -- PREP: fork_known_entries
 INSERT INTO known_entries (
 	run_id, loop_id, turn, path, body, status, fidelity
-	, hash, attributes, tokens, tokens_full, refs, write_count
+	, hash, attributes, tokens, refs, write_count
 )
 SELECT
 	:new_run_id, NULL, turn, path, body, status, fidelity
-	, hash, attributes, tokens, tokens_full, refs, write_count
+	, hash, attributes, tokens, refs, write_count
 FROM known_entries
 WHERE run_id = :parent_run_id;
 

package/src/agent/tokens.js

@@ -6,6 +6,7 @@
  */
 
 const DIVISOR = Number(process.env.RUMMY_TOKEN_DIVISOR);
+if (!DIVISOR) throw new Error("RUMMY_TOKEN_DIVISOR must be a non-zero number");
 
 export function countTokens(text) {
 	if (!text) return 0;

package/src/agent/turns.sql

@@ -27,6 +27,11 @@ SELECT
 FROM turns
 WHERE run_id = :run_id;
 
+-- PREP: get_turn_context_tokens
+SELECT context_tokens
+FROM turns
+WHERE run_id = :run_id AND sequence = :sequence;
+
 -- PREP: get_last_context_tokens
 SELECT context_tokens
 FROM turns

package/src/hooks/HookRegistry.js

@@ -63,6 +63,13 @@ export default class HookRegistry {
 		this.#events.get(tag).sort((a, b) => a.priority - b.priority);
 	}
 
+	removeEvent(tag, callback) {
+		const hooks = this.#events.get(tag);
+		if (!hooks) return;
+		const idx = hooks.findIndex((h) => h.callback === callback);
+		if (idx !== -1) hooks.splice(idx, 1);
+	}
+
 	async emitEvent(tag, ...args) {
 		const hooks = this.#events.get(tag) || [];
 		for (const h of hooks) {

package/src/hooks/Hooks.js

@@ -11,6 +11,7 @@ export default function createHooks(debug = false) {
 
 	const createEvent = (tag) => ({
 		on: (callback, priority) => registry.addEvent(tag, callback, priority),
+		off: (callback) => registry.removeEvent(tag, callback),
 		emit: (...args) => registry.emitEvent(tag, ...args),
 	});
 
@@ -55,6 +56,7 @@ export default function createHooks(debug = false) {
 		turn: {
 			started: createEvent("turn.started"),
 			response: createEvent("turn.response"),
+			proposal: createEvent("turn.proposal"),
 			proposing: createEvent("turn.proposing"),
 			completed: createEvent("turn.completed"),
 		},
@@ -73,10 +75,6 @@ export default function createHooks(debug = false) {
 			started: createEvent("act.started"),
 			completed: createEvent("act.completed"),
 		},
-		panic: {
-			started: createEvent("panic.started"),
-			completed: createEvent("panic.completed"),
-		},
 		llm: {
 			request: {
 				started: createEvent("llm.request.started"),

package/src/hooks/ToolRegistry.js

@@ -1,19 +1,20 @@
 // Tool display order: gather → reason → act → communicate.
 // Position in the list implies priority to the model.
 const TOOL_ORDER = [
+	"think",
+	"unknown",
+	"known",
 	"get",
 	"set",
-	"known",
-	"unknown",
 	"env",
 	"sh",
 	"rm",
 	"cp",
 	"mv",
-	"search",
-	"summarize",
-	"update",
 	"ask_user",
+	"update",
+	"summarize",
+	"search",
 ];
 
 function sortByPriority(names) {
@@ -118,19 +119,13 @@ export default class ToolRegistry {
 	 */
 	resolveForLoop(
 		mode,
-		{ noInteraction = false, noWeb = false, noBench = false } = {},
+		{ noInteraction = false, noWeb = false, noProposals = false } = {},
 	) {
 		const excluded = new Set();
 		if (mode === "ask") excluded.add("sh");
-		if (mode === "panic") {
-			excluded.add("sh");
-			excluded.add("env");
-			excluded.add("search");
-			excluded.add("ask_user");
-		}
 		if (noInteraction) excluded.add("ask_user");
 		if (noWeb) excluded.add("search");
-		if (noBench) {
+		if (noProposals) {
 			excluded.add("ask_user");
 			excluded.add("env");
 			excluded.add("sh");

package/src/plugins/ask_user/ask_userDoc.js

@@ -2,27 +2,22 @@
 // Text goes to the model. Rationale stays in source.
 // Changing ANY line requires reading ALL rationales first.
 const LINES = [
-	// --- Syntax: question attr + options in body
 	['## <ask_user question="[Question?]">[option1; option2; ...]</ask_user>'],
-
-	// --- Constraints FIRST: frames correct usage before examples
 	[
 		"* YOU SHOULD use for decisions, preferences, or approvals the user must make",
-		"Positive framing. Shows what ask_user IS for, not just what it isn't.",
+		"Positive framing. Shows what ask_user IS for.",
 	],
 	[
 		"* YOU SHOULD use <get> to find information before asking the user",
-		"Gentle redirect. Encourages self-sufficiency without forbidding interaction.",
+		"Gentle redirect. Encourages self-sufficiency.",
 	],
-
-	// --- Examples: genuine decision points where user input is valuable
 	[
 		'Example: <ask_user question="Which test framework?">Mocha; Jest; Node Native</ask_user>',
 		"Preference decision. Model truly cannot know this without asking.",
 	],
 	[
 		'Example: <ask_user question="Deploy to staging or production?">staging; production</ask_user>',
-		"Consequential action. Shows ask_user for high-stakes choices.",
+		"Consequential action. High-stakes choice.",
 	],
 ];
 

package/src/plugins/budget/README.md

@@ -1,43 +1,39 @@
 # budget
 
-Context ceiling enforcement and panic mode recovery.
+Context ceiling enforcement.
 
-## Files
-
-- **budget.js** — Plugin. Pre-LLM enforce, BudgetGuard activation,
-  panic prompt generation.
-- **BudgetGuard.js** — Write-layer gate. Installed on KnownStore during
-  dispatch. Checks token delta on every upsert, promote, and body update.
-
-## Registration
+## Design
 
-- **Hook**: `hooks.budget.enforce` — pre-LLM ceiling check.
-- **Hook**: `hooks.budget.activate(store, contextSize, assembledTokens)` — install guard.
-- **Hook**: `hooks.budget.deactivate(store)` — remove guard.
-- **Hook**: `hooks.budget.panicPrompt({ shortfall, assembledTokens, contextSize })` — generate panic prompt.
+Ceiling = `floor(contextSize × 0.9)`. The 10% headroom is the system's
+operating room for graceful overflow handling. No per-write gating —
+tools run uninterrupted. Enforcement happens at boundaries.
 
-## Budget Contract
+## Enforcement Points
 
-`contextSize` is the ceiling. `countTokens()` is the measurement.
-Over = 413. Under = 200. No margins.
+1. **Pre-LLM enforce** (`budget.enforce`): checks assembled context
+   before the LLM call. If over ceiling → Prompt Demotion (summarize
+   the incoming prompt). Model runs in the headroom.
 
-## BudgetGuard
+2. **Post-dispatch Turn Demotion**: after all tools dispatch, check
+   context. If over ceiling → demote ALL entries from this turn to
+   summary (every scheme except `budget`). Write `budget://` entry
+   listing what was demoted. Model sees it next turn and adapts.
 
-Installed on KnownStore by TurnExecutor before dispatch, cleared in
-`finally`. Gates `upsert()`, `promoteByPattern()`, `updateBodyByPattern()`.
+3. **LLM rejection** (`isContextExceeded`): turn-1 token estimate
+   drift causes LLM to reject. Same demotion pattern.
 
-Exemptions: `status >= 400` (error entries), `model_visible = 0` (audit),
-`fidelity = "archive"` (not in context).
+4. **AgentLoop recovery**: pre-LLM 413 that Prompt Demotion can't
+   resolve. Batch-demote all full entries, budget entry, model gets
+   recovery turns. 3 strikes without progress → hard 413 to client.
+   Only path where 413 reaches the client.
 
-On first violation: `BudgetExceeded` thrown, guard trips, all subsequent
-writes fail. TurnExecutor catches per-tool, writes 413 result entry.
+## Files
 
-## Panic Mode
+- **budget.js** — Plugin. Pre-LLM enforce hook.
+- **BudgetGuard.js** — `BudgetExceeded` error type, `delta` utility.
 
-When a new prompt exceeds the ceiling, AgentLoop enqueues a panic loop.
-The model receives the exact shortfall and must free space using core
-tools (get, set, known, unknown, rm, mv, cp, summarize, update).
-Excluded: sh, env, search, ask_user.
+## Registration
 
-Strike system: 3 consecutive turns without context reduction = hard 413.
-Any reduction resets the counter. One panic attempt per drain cycle.
+- **Hook**: `hooks.budget.enforce` — pre-LLM ceiling check.
+- **Scheme**: `budget://` — logging category, model-visible. `onView`
+  renders body at all fidelity levels (summary shows full content).

package/src/plugins/budget/budget.js

@@ -1,56 +1,44 @@
 import { countTokens } from "../../agent/tokens.js";
-import BudgetGuard, { BudgetExceeded } from "./BudgetGuard.js";
+
+const CEILING_RATIO = Number(process.env.RUMMY_BUDGET_CEILING);
+if (!CEILING_RATIO) throw new Error("RUMMY_BUDGET_CEILING must be set");
 
 function measureMessages(messages) {
 	return messages.reduce((sum, m) => sum + countTokens(m.content), 0);
 }
 
-export { BudgetExceeded };
-
 export default class Budget {
 	#core;
 
 	constructor(core) {
 		this.#core = core;
+		core.registerScheme({
+			name: "budget",
+			modelVisible: 1,
+			category: "logging",
+		});
+		core.hooks.tools.onView("budget", (entry) => entry.body);
 		core.hooks.budget = {
 			enforce: this.enforce.bind(this),
-			activate: this.activate.bind(this),
-			deactivate: this.deactivate.bind(this),
-			panicPrompt: Budget.panicPrompt,
-			BudgetExceeded,
+			postDispatch: this.postDispatch.bind(this),
 		};
 	}
 
-	static panicPrompt({ assembledTokens, contextSize }) {
-		const target = Math.floor(contextSize * 0.75);
-		const mustFree = assembledTokens - target;
-		return [
-			`CONTEXT OVERFLOW: ${assembledTokens} tokens, ceiling ${contextSize}.`,
-			`YOU MUST free ${mustFree} tokens to get below ${target} (75%).`,
-			"YOU MUST NOT load or create new content. Only reduce.",
-			"",
-			"<knowns> above shows each entry with its token count.",
-			"Target the largest entries first.",
-			'<rm path="..."/> to delete entries you no longer need.',
-			'<set path="..." fidelity="summary" summary="keywords"/> to compress.',
-			'<set path="..." fidelity="archive"/> to archive out of context.',
-			"<summarize/> when done. <update/> if still working.",
-		].join("\n");
-	}
-
-	async enforce({ contextSize, messages, rows }) {
+	async enforce({ contextSize, messages, rows, lastPromptTokens = 0 }) {
 		if (!contextSize) {
 			return { messages, rows, demoted: [], assembledTokens: 0, status: 200 };
 		}
 
-		const assembledTokens = measureMessages(messages);
+		const assembledTokens =
+			lastPromptTokens > 0 ? lastPromptTokens : measureMessages(messages);
 
 		console.warn(
-			`[RUMMY] Budget enforce: ${assembledTokens} tokens, ceiling ${contextSize}, ${rows.length} rows`,
+			`[RUMMY] Budget enforce: ${assembledTokens} tokens (${lastPromptTokens > 0 ? "actual" : "estimated"}), ceiling ${contextSize}, ${rows.length} rows`,
 		);
 
-		if (assembledTokens > contextSize) {
-			const overflow = assembledTokens - contextSize;
+		const ceiling = Math.floor(contextSize * CEILING_RATIO);
+		if (assembledTokens > ceiling) {
+			const overflow = assembledTokens - ceiling;
 			console.warn(
 				`[RUMMY] Budget 413: ${assembledTokens} tokens > ${contextSize} ceiling (${overflow} over)`,
 			);
@@ -67,13 +55,58 @@ export default class Budget {
 		return { messages, rows, demoted: [], assembledTokens, status: 200 };
 	}
 
-	activate(store, contextSize, assembledTokens) {
-		const guard = new BudgetGuard(contextSize, assembledTokens);
-		store.budgetGuard = guard;
-		return guard;
-	}
+	async postDispatch({
+		contextSize,
+		messages,
+		rows,
+		runId,
+		loopId,
+		turn,
+		db,
+		store,
+	}) {
+		if (!contextSize) return null;
+
+		const postBudget = await this.enforce({
+			contextSize,
+			messages,
+			rows,
+			lastPromptTokens: 0,
+		});
+
+		if (postBudget.status !== 413) return null;
 
-	deactivate(store) {
-		store.budgetGuard = null;
+		// Demote this turn's entries
+		const demotedEntries = await db.demote_turn_entries.all({
+			run_id: runId,
+			turn,
+		});
+
+		// Also summarize the prompt
+		const promptRow = rows.find((r) => r.scheme === "prompt");
+		if (promptRow) {
+			await store.setFidelity(runId, promptRow.path, "summary");
+		}
+
+		// Write budget entry
+		const ceiling = Math.floor(contextSize * CEILING_RATIO);
+		const totalDemoted = demotedEntries.reduce((s, r) => s + r.tokens, 0);
+		const pathList = demotedEntries
+			.map((r) => `${r.path} (${r.tokens} tokens)`)
+			.join("\n");
+		const body = [
+			`Error 413: Context overflowed by ${postBudget.overflow} tokens.`,
+			`${demotedEntries.length} entries (${totalDemoted} tokens total) demoted. Budget: ${ceiling} tokens.`,
+			pathList,
+		].join("\n");
+
+		await store.upsert(runId, turn, `budget://${loopId}/${turn}`, body, 413, {
+			loopId,
+		});
+
+		return {
+			target: ceiling,
+			promptPath: promptRow?.path ?? null,
+		};
 	}
 }

package/src/plugins/budget/recovery.js

@@ -0,0 +1,47 @@
+/**
+ * Pure recovery state transition — exported for testing.
+ *
+ * @param {object|null} recovery  Current recovery state.
+ * @param {{ assembledTokens: number, budgetRecovery?: { target: number, promptPath: string|null } }} result
+ * @returns {{ next: object|null, action: null|'restore'|'hard413', promptPath: string|null }}
+ */
+export function advanceRecovery(recovery, result) {
+	// Initialise or update recovery state from a new Turn Demotion event.
+	if (result.budgetRecovery) {
+		if (!recovery) {
+			recovery = {
+				target: result.budgetRecovery.target,
+				promptPath: result.budgetRecovery.promptPath,
+				strikes: 0,
+				lastTokens: result.assembledTokens,
+			};
+		} else {
+			// Re-overflow during recovery: tighten target, don't count as strike.
+			recovery = {
+				...recovery,
+				target: Math.min(recovery.target, result.budgetRecovery.target),
+			};
+		}
+	}
+
+	if (recovery === null) return { next: null, action: null, promptPath: null };
+
+	const current = result.assembledTokens;
+
+	if (current <= recovery.target) {
+		return { next: null, action: "restore", promptPath: recovery.promptPath };
+	}
+
+	const noProgress = current >= recovery.lastTokens && !result.budgetRecovery;
+	const strikes = noProgress ? recovery.strikes + 1 : 0;
+
+	if (strikes >= 3) {
+		return { next: null, action: "hard413", promptPath: null };
+	}
+
+	return {
+		next: { ...recovery, strikes, lastTokens: current },
+		action: null,
+		promptPath: null,
+	};
+}

package/src/plugins/cp/cp.js

@@ -19,7 +19,7 @@ export default class Cp {
 	async handler(entry, rummy) {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 		const { path, to } = entry.attributes;
-		const VALID = { stored: 1, summary: 1, index: 1, full: 1 };
+		const VALID = { stored: 1, summary: 1, index: 1, full: 1, archive: 1 };
 		const fidelity = VALID[entry.attributes.fidelity]
 			? entry.attributes.fidelity
 			: undefined;