@possumtech/rummy 0.3.0 → 0.4.0

package/src/agent/TurnExecutor.js

@@ -6,6 +6,10 @@ import ResponseHealer from "./ResponseHealer.js";
 import { countTokens } from "./tokens.js";
 import XmlParser from "./XmlParser.js";
 
+const ACTION_SCHEMES = new Set(["get", "set", "rm", "mv", "cp", "sh", "env", "search"]);
+const MUTATION_SCHEMES = new Set(["set", "rm", "sh", "mv", "cp"]);
+const READ_SCHEMES = new Set(["get", "env", "search"]);
+
 export default class TurnExecutor {
 	#db;
 	#llmProvider;
@@ -19,6 +23,68 @@ export default class TurnExecutor {
 		this.#knownStore = knownStore;
 	}
 
+	/**
+	 * Rebuild turn_context from v_model_context, then assemble messages.
+	 * Called at turn start and again after any fidelity demotion within the turn.
+	 */
+	async #materializeTurnContext({
+		runId,
+		loopId,
+		turn,
+		systemPrompt,
+		mode,
+		toolSet,
+		contextSize,
+		demoted,
+	}) {
+		await this.#db.clear_turn_context.run({ run_id: runId, turn });
+		const viewRows = await this.#db.get_model_context.all({ run_id: runId });
+		for (const row of viewRows) {
+			const scheme = row.scheme || "file";
+			const projectedBody = await this.#hooks.tools.view(scheme, {
+				path: row.path,
+				scheme,
+				body: row.body,
+				attributes: row.attributes ? JSON.parse(row.attributes) : null,
+				fidelity: row.fidelity,
+				category: row.category,
+			});
+			await this.#db.insert_turn_context.run({
+				run_id: runId,
+				loop_id: loopId,
+				turn,
+				ordinal: row.ordinal,
+				path: row.path,
+				fidelity: row.fidelity,
+				status: row.status,
+				body: projectedBody ?? "",
+				tokens: countTokens(projectedBody ?? ""),
+				attributes: row.attributes,
+				category: row.category,
+				source_turn: row.turn,
+			});
+		}
+		const rows = await this.#db.get_turn_context.all({ run_id: runId, turn });
+		const lastCtx = await this.#db.get_last_context_tokens.get({
+			run_id: runId,
+		});
+		const lastContextTokens = lastCtx?.context_tokens ?? 0;
+		const messages = await ContextAssembler.assembleFromTurnContext(
+			rows,
+			{
+				type: mode,
+				systemPrompt,
+				contextSize,
+				demoted,
+				toolSet,
+				lastContextTokens,
+				turn,
+			},
+			this.#hooks,
+		);
+		return { rows, messages, lastContextTokens };
+	}
+
 	async execute({
 		mode,
 		project,
@@ -28,12 +94,25 @@ export default class TurnExecutor {
 		currentLoopId,
 		requestedModel,
 		loopPrompt,
+		loopIteration,
 		noRepo,
 		toolSet,
+		inRecovery = false,
 		contextSize,
 		options,
 		signal,
 	}) {
+		const RECOVERY_EXCLUDED = new Set([
+			"sh",
+			"env",
+			"search",
+			"ask_user",
+			"set",
+		]);
+		const effectiveToolSet = inRecovery
+			? new Set([...toolSet].filter((t) => !RECOVERY_EXCLUDED.has(t)))
+			: toolSet;
+
 		const turn = await this.#knownStore.nextTurn(currentRunId);
 
 		const turnRow = await this.#db.create_turn.get({
@@ -42,13 +121,6 @@ export default class TurnExecutor {
 			sequence: turn,
 		});
 
-		const unresolved = await this.#knownStore.getUnresolved(currentRunId);
-		if (unresolved.length > 0) {
-			throw new Error(
-				msg("error.unresolved_proposed", { count: unresolved.length }),
-			);
-		}
-
 		// Build RummyContext before turn.started so plugins can write entries
 		const rummy = new RummyContext(
 			{
@@ -73,7 +145,7 @@ export default class TurnExecutor {
 				loopId: currentLoopId,
 				turnId: turnRow.id,
 				noRepo,
-				toolSet,
+				toolSet: effectiveToolSet,
 				contextSize,
 				systemPrompt: null,
 				loopPrompt,
@@ -85,6 +157,7 @@ export default class TurnExecutor {
 			mode,
 			prompt: loopPrompt,
 			isContinuation: options?.isContinuation,
+			loopIteration,
 		});
 
 		await this.#hooks.processTurn(rummy);
@@ -111,43 +184,23 @@ export default class TurnExecutor {
 		});
 
 		// Materialize turn_context: VIEW rows projected through tools
-		await this.#db.clear_turn_context.run({ run_id: currentRunId, turn });
-		const viewRows = await this.#db.get_model_context.all({
-			run_id: currentRunId,
-		});
-		for (const row of viewRows) {
-			const scheme = row.scheme || "file";
-			const projectedBody = await this.#hooks.tools.view(scheme, {
-				path: row.path,
-				scheme,
-				body: row.body,
-				attributes: row.attributes ? JSON.parse(row.attributes) : null,
-				fidelity: row.fidelity,
-				category: row.category,
-			});
-
-			await this.#db.insert_turn_context.run({
-				run_id: currentRunId,
-				loop_id: currentLoopId,
+		const demoted = [];
+		let { rows, messages, lastContextTokens } =
+			await this.#materializeTurnContext({
+				runId: currentRunId,
+				loopId: currentLoopId,
 				turn,
-				ordinal: row.ordinal,
-				path: row.path,
-				fidelity: row.fidelity,
-				status: row.status,
-				body: projectedBody ?? "",
-				tokens: countTokens(projectedBody ?? ""),
-				attributes: row.attributes,
-				category: row.category,
-				source_turn: row.turn,
+				systemPrompt,
+				mode,
+				toolSet: effectiveToolSet,
+				contextSize,
+				demoted,
 			});
-		}
-
-		const demoted = [];
 
 		await this.#hooks.context.materialized.emit({
 			runId: currentRunId,
 			turn,
-			rowCount: viewRows.length,
+			rowCount: rows.length,
 		});
 
 		await this.#hooks.run.progress.emit({
@@ -157,50 +210,75 @@ export default class TurnExecutor {
 			status: "thinking",
 		});
 
-		let rows = await this.#db.get_turn_context.all({
-			run_id: currentRunId,
-			turn,
-		});
-		const lastCtx = await this.#db.get_last_context_tokens.get({
-			run_id: currentRunId,
-		});
-		const lastContextTokens = lastCtx?.context_tokens ?? 0;
-
-		let messages = await ContextAssembler.assembleFromTurnContext(
-			rows,
-			{
-				type: mode,
-				systemPrompt,
-				contextSize,
-				demoted,
-				toolSet,
-				lastContextTokens,
-			},
-			this.#hooks,
-		);
-
 		const budgetResult = await this.#hooks.budget.enforce({
 			contextSize,
 			messages,
 			rows,
+			lastPromptTokens: lastContextTokens,
 		});
 		messages = budgetResult.messages;
 		rows = budgetResult.rows;
-		const assembledTokens =
+		let assembledTokens =
 			budgetResult.assembledTokens ??
 			messages.reduce((sum, m) => sum + countTokens(m.content), 0);
 
-		// Budget overflow — return 413 to caller without calling LLM.
-		// Panic mode suppresses this — the model must run to free space.
-		if (budgetResult.status === 413 && mode !== "panic") {
-			return {
-				turn,
-				turnId: turnRow.id,
-				status: 413,
-				assembledTokens,
-				contextSize,
-				overflow: budgetResult.overflow,
-			};
+		if (budgetResult.status === 413) {
+			if (loopIteration === 1) {
+				// Prompt Demotion: first-turn overflow — demote incoming prompt to summary
+				const promptRow = rows.findLast(
+					(r) => r.category === "prompt" && r.scheme === "prompt",
+				);
+				if (promptRow) {
+					await this.#knownStore.setFidelity(
+						currentRunId,
+						promptRow.path,
+						"summary",
+					);
+				}
+				const reMat = await this.#materializeTurnContext({
+					runId: currentRunId,
+					loopId: currentLoopId,
+					turn,
+					systemPrompt,
+					mode,
+					toolSet: effectiveToolSet,
+					contextSize,
+					demoted,
+				});
+				rows = reMat.rows;
+				messages = reMat.messages;
+				const recheck = await this.#hooks.budget.enforce({
+					contextSize,
+					messages,
+					rows,
+					lastPromptTokens: reMat.lastContextTokens,
+				});
+				messages = recheck.messages;
+				rows = recheck.rows;
+				assembledTokens =
+					recheck.assembledTokens ??
+					messages.reduce((sum, m) => sum + countTokens(m.content), 0);
+				if (recheck.status === 413) {
+					return {
+						turn,
+						turnId: turnRow.id,
+						status: 413,
+						assembledTokens,
+						contextSize,
+						overflow: recheck.overflow,
+					};
+				}
+			} else {
+				// Base context too large even without new prompt — genuine failure
+				return {
+					turn,
+					turnId: turnRow.id,
+					status: 413,
+					assembledTokens,
+					contextSize,
+					overflow: budgetResult.overflow,
+				};
+			}
 		}
 
 		const filteredMessages = await this.#hooks.llm.messages.filter(messages, {
@@ -216,6 +294,10 @@ export default class TurnExecutor {
 			/\b(503|429|timeout|ECONNREFUSED|ECONNRESET|unavailable)\b/i.test(
 				e.message,
 			);
+		const isContextExceeded = (e) =>
+			/\b(context.*(size|length|limit)|token.*(limit|exceed)|too.*(long|large))\b/i.test(
+				e.message,
+			);
 
 		for (let llmAttempt = 0; ; llmAttempt++) {
 			try {
@@ -234,6 +316,18 @@ export default class TurnExecutor {
 					await new Promise((r) => setTimeout(r, delay));
 					continue;
 				}
+				if (isContextExceeded(err)) {
+					console.warn(
+						`[RUMMY] LLM context exceeded: ${err.message.slice(0, 120)}. Returning 413.`,
+					);
+					return {
+						turn,
+						turnId: turnRow.id,
+						status: 413,
+						assembledTokens,
+						contextSize,
+					};
+				}
 				throw err;
 			}
 		}
@@ -290,15 +384,7 @@ export default class TurnExecutor {
 		});
 
 		// --- PHASE 1: RECORD ---
-		// Split lifecycle signals from action commands.
-		// Lifecycle signals (summarize, update, unknown, known) are state
-		// declarations — always recorded, never 409'd by sequential dispatch.
-		const LIFECYCLE = new Set(["summarize", "update", "unknown", "known"]);
-
 		const recorded = [];
-		const lifecycle = [];
-		const actions = [];
-
 		for (const cmd of commands) {
 			const entry = await this.#record(
 				currentRunId,
@@ -307,125 +393,114 @@ export default class TurnExecutor {
 				mode,
 				cmd,
 			);
-			if (!entry) continue;
-			recorded.push(entry);
-
-			if (LIFECYCLE.has(entry.scheme)) {
-				lifecycle.push(entry);
-			} else {
-				actions.push(entry);
-			}
+			if (entry) recorded.push(entry);
 		}
 
 		// --- PHASE 2: DISPATCH ---
-		// Budget plugin activates the guard on the store for dispatch.
-		const guard = this.#hooks.budget.activate(
-			this.#knownStore,
-			contextSize,
-			assembledTokens,
-		);
-		const { BudgetExceeded } = this.#hooks.budget;
-
+		// Sequential queue. Each tool completes before the next starts.
+		// On failure: abort remaining. On proposal: notify client, await
+		// resolution, continue.
 		let hasErrors = false;
-		let hasProposed = false;
 		let abortAfter = null;
-		const dispatched = [...lifecycle];
-
-		try {
-			// Lifecycle signals first — always dispatched, never aborted.
-			for (const entry of lifecycle) {
-				await this.#hooks.tool.before.emit({ entry, rummy });
-				await this.#hooks.tools.dispatch(entry.scheme, entry, rummy);
-				await this.#hooks.tool.after.emit({ entry, rummy });
-				await this.#hooks.entry.created.emit(entry);
+
+		for (const entry of recorded) {
+			if (abortAfter) {
+				const errorMsg = `Aborted — preceding <${abortAfter}> failed.`;
+				await this.#knownStore.upsert(
+					currentRunId,
+					turn,
+					entry.resultPath || entry.path,
+					errorMsg,
+					409,
+					{ attributes: { error: errorMsg }, loopId: currentLoopId },
+				);
+				hasErrors = true;
+				continue;
 			}
 
-			for (const entry of actions) {
-				if (abortAfter || guard.isTripped) {
-					await this.#knownStore.upsert(
-						currentRunId,
-						turn,
-						entry.resultPath || entry.path,
-						"",
-						guard.isTripped ? 413 : 409,
-						{
-							attributes: {
-								error: guard.isTripped
-									? `Budget exceeded by <${guard.tripSource}>.`
-									: `Aborted — preceding <${abortAfter}> requires resolution.`,
-							},
-							loopId: currentLoopId,
-						},
-					);
+			await this.#hooks.tool.before.emit({ entry, rummy });
+			await this.#hooks.tools.dispatch(entry.scheme, entry, rummy);
+			await this.#hooks.tool.after.emit({ entry, rummy });
+			await this.#hooks.entry.created.emit(entry);
+
+			// Materialize proposals for this entry (set revisions → 202)
+			await this.#hooks.turn.proposing.emit({ rummy, recorded: [entry] });
+
+			// Check for any proposals created by this entry's dispatch
+			const proposed = await this.#knownStore.getUnresolved(currentRunId);
+			for (const p of proposed) {
+				await this.#hooks.turn.proposal.emit({
+					projectId,
+					run: currentAlias,
+					proposed: [p],
+				});
+				await this.#knownStore.waitForResolution(currentRunId, p.path);
+				const resolved = await this.#db.get_entry_state.get({
+					run_id: currentRunId,
+					path: p.path,
+				});
+				if (resolved?.status >= 400) {
 					hasErrors = true;
-					continue;
-				}
-
-				try {
-					await this.#hooks.tool.before.emit({ entry, rummy });
-					await this.#hooks.tools.dispatch(entry.scheme, entry, rummy);
-					await this.#hooks.tool.after.emit({ entry, rummy });
-					await this.#hooks.entry.created.emit(entry);
-					dispatched.push(entry);
-				} catch (err) {
-					if (err instanceof BudgetExceeded) {
-						guard.trip(entry.scheme);
-						await this.#knownStore.upsert(
-							currentRunId,
-							turn,
-							entry.resultPath || entry.path,
-							`Budget exceeded: ${err.requested} tokens requested, ${err.remaining} remaining.`,
-							413,
-							{ attributes: { error: err.message }, loopId: currentLoopId },
-						);
-						hasErrors = true;
-						abortAfter = entry.scheme;
-						continue;
-					}
-					throw err;
+					abortAfter = entry.scheme;
 				}
+			}
 
+			// Also check the entry itself for direct failures
+			if (!hasErrors) {
+				const entryPath = entry.resultPath || entry.path;
 				const row = await this.#db.get_entry_state.get({
 					run_id: currentRunId,
-					path: entry.resultPath || entry.path,
+					path: entryPath,
 				});
-				if (row?.status === 202) {
-					hasProposed = true;
-					abortAfter = entry.scheme;
-				} else if (row?.status >= 400) {
+				if (row?.status >= 400) {
 					hasErrors = true;
 					abortAfter = entry.scheme;
 				}
 			}
+		}
 
-			// Materialize proposals only if we dispatched actions
-			if (!abortAfter || hasProposed) {
-				await this.#hooks.turn.proposing.emit({ rummy, recorded: dispatched });
-			}
-
-			// Recheck after materialization (set handler may create proposals)
-			if (!hasProposed && !hasErrors) {
-				for (const entry of actions) {
-					const row = await this.#db.get_entry_state.get({
-						run_id: currentRunId,
-						path: entry.resultPath || entry.path,
-					});
-					if (row?.status === 202) hasProposed = true;
-					if (row?.status >= 400) hasErrors = true;
-				}
-			}
-		} finally {
-			this.#hooks.budget.deactivate(this.#knownStore);
+		// Turn Demotion: if end-of-turn context exceeds ceiling, demote this
+		// turn's data entries and the incoming prompt to summary, then force a
+		// budget recovery phase before continuing.
+		let budgetRecovery = null;
+		// Use actual prompt_tokens from this turn's LLM response as the ground-truth
+		// Post-dispatch budget check — demotion handled by budget plugin
+		if (contextSize) {
+			const postMat = await this.#materializeTurnContext({
+				runId: currentRunId,
+				loopId: currentLoopId,
+				turn,
+				systemPrompt,
+				mode,
+				toolSet: effectiveToolSet,
+				contextSize,
+				demoted,
+			});
+			budgetRecovery = await this.#hooks.budget.postDispatch({
+				contextSize,
+				messages: postMat.messages,
+				rows: postMat.rows,
+				runId: currentRunId,
+				loopId: currentLoopId,
+				turn,
+				db: this.#db,
+				store: this.#knownStore,
+			});
 		}
 
-		// Lifecycle signals are always available — never 409'd.
-		const summaryEntry = lifecycle.find((e) => e.scheme === "summarize");
-		const updateEntry = lifecycle.find((e) => e.scheme === "update");
+		const summaryEntry = recorded.findLast((e) => e.scheme === "summarize");
+		const updateEntry = recorded.findLast((e) => e.scheme === "update");
 		let summaryText = summaryEntry?.body || null;
 		let updateText = updateEntry?.body || null;
 
-		// If model sent both, update wins — if it can't decide, it's not done
-		if (summaryText && updateText) summaryText = null;
+		// If model sent both, last signal wins — respects the model's final intent
+		if (summaryText && updateText) {
+			const lastLifecycle = recorded.findLast(
+				(e) => e.scheme === "summarize" || e.scheme === "update",
+			);
+			if (lastLifecycle.scheme === "summarize") updateText = null;
+			else summaryText = null;
+		}
 
 		// If model says "done" but actions failed, override — the model's
 		// assertion that it's done is false if it failed to do what it tried.
@@ -433,6 +508,15 @@ export default class TurnExecutor {
 			console.warn(
 				"[RUMMY] Overriding <summarize> — actions in this turn failed. Continuing.",
 			);
+			// Mark the recorded summarize entry as 409 so the model sees it was rejected
+			if (summaryEntry?.path) {
+				await this.#knownStore.resolve(
+					currentRunId,
+					summaryEntry.path,
+					409,
+					"Overridden — actions in this turn failed. Use <update/> until resolved.",
+				);
+			}
 			updateText = summaryText;
 			summaryText = null;
 		}
@@ -448,11 +532,7 @@ export default class TurnExecutor {
 
 		// --- Classify for return value ---
 
-		const actionCalls = recorded.filter((e) =>
-			["get", "set", "rm", "mv", "cp", "sh", "env", "search"].includes(
-				e.scheme,
-			),
-		);
+		const actionCalls = recorded.filter((e) => ACTION_SCHEMES.has(e.scheme));
 		const writeCalls = recorded.filter(
 			(e) =>
 				e.scheme === "known" ||
@@ -460,12 +540,8 @@ export default class TurnExecutor {
 		);
 		const unknownCalls = recorded.filter((e) => e.scheme === "unknown");
 
-		const hasAct = actionCalls.some((c) =>
-			["set", "rm", "sh", "mv", "cp"].includes(c.scheme),
-		);
-		const hasReads = actionCalls.some((c) =>
-			["get", "env", "search"].includes(c.scheme),
-		);
+		const hasAct = actionCalls.some((c) => MUTATION_SCHEMES.has(c.scheme));
+		const hasReads = actionCalls.some((c) => READ_SCHEMES.has(c.scheme));
 		const hasWrites = writeCalls.length > 0 || unknownCalls.length > 0;
 		const flags = { hasAct, hasReads, hasWrites };
 
@@ -484,12 +560,11 @@ export default class TurnExecutor {
 			flags,
 			model: result.model || requestedModel,
 			modelAlias: requestedModel,
-			temperature:
-				options?.temperature ??
-				Number.parseFloat(process.env.RUMMY_TEMPERATURE || "0.7"),
+			temperature: options?.temperature,
 			contextSize,
 			assembledTokens,
 			usage: result.usage,
+			budgetRecovery,
 		};
 
 		await this.#hooks.turn.completed.emit(turnResult);
@@ -502,85 +577,33 @@ export default class TurnExecutor {
 	 * Returns the recorded entry descriptor, or null if rejected/skipped.
 	 */
 	async #record(runId, loopId, turn, mode, cmd) {
-		// Mode enforcement — reject prohibited commands in ask/panic mode
-		if (mode === "ask" || mode === "panic") {
-			if (cmd.name === "sh") {
-				console.warn("[RUMMY] Rejected <sh> in ask mode");
-				return null;
-			}
-			if (cmd.name === "set" && cmd.path && cmd.body) {
-				const scheme = KnownStore.scheme(cmd.path);
-				if (scheme === null) {
-					console.warn(
-						`[RUMMY] Rejected file edit to ${cmd.path} in ${mode} mode`,
-					);
-					return null;
-				}
-			}
-			if (cmd.name === "rm" && cmd.path) {
-				const scheme = KnownStore.scheme(cmd.path);
-				if (scheme === null) {
-					console.warn(`[RUMMY] Rejected file rm of ${cmd.path} in ask mode`);
-					return null;
-				}
-			}
-			if ((cmd.name === "mv" || cmd.name === "cp") && cmd.to) {
-				const destScheme = KnownStore.scheme(cmd.to);
-				if (destScheme === null) {
-					console.warn(
-						`[RUMMY] Rejected ${cmd.name} to file ${cmd.to} in ask mode`,
-					);
-					return null;
-				}
-			}
-		}
-
 		const scheme = cmd.name;
-
-		// Structural tags — recorded like any other entry
-		if (scheme === "summarize" || scheme === "update") {
-			const statusPath = await this.#knownStore.slugPath(
+		const rawTarget = cmd.path || cmd.command || cmd.question || "";
+		// Reject paths that are likely reasoning bleed — too long or contain non-printing chars
+		if (rawTarget.length > 512 || /\p{Cc}/u.test(rawTarget)) {
+			const rejectPath = await this.#knownStore.dedup(
 				runId,
 				scheme,
-				cmd.body,
+				`${scheme}://invalid`,
+				turn,
 			);
-			await this.#knownStore.upsert(runId, turn, statusPath, cmd.body, 200, {
-				loopId,
-			});
-			return {
-				scheme,
-				body: cmd.body,
-				path: statusPath,
-				resultPath: statusPath,
-				attributes: null,
-			};
-		}
-
-		// Unknown — deduplicated, sticky
-		if (scheme === "unknown") {
-			const existingValues = await this.#knownStore.getUnknownValues(runId);
-			if (existingValues.has(cmd.body)) {
-				console.warn(`[RUMMY] Unknown deduped: "${cmd.body.slice(0, 60)}"`);
-				return null;
-			}
-			const unknownPath = await this.#knownStore.slugPath(
+			await this.#knownStore.upsert(
 				runId,
-				"unknown",
-				cmd.body,
+				turn,
+				rejectPath,
+				`Invalid path: too long or contains non-printing characters`,
+				400,
+				{ loopId },
 			);
-			await this.#knownStore.upsert(runId, turn, unknownPath, cmd.body, 200, {
-				loopId,
-			});
 			return {
 				scheme,
-				path: unknownPath,
-				body: cmd.body,
-				resultPath: unknownPath,
-				attributes: null,
+				path: rejectPath,
+				body: "",
+				attributes: {},
+				status: 400,
+				resultPath: rejectPath,
 			};
 		}
-
-		const rawTarget = cmd.path || cmd.command || cmd.question || "";
 		const target = rawTarget;
 		const resultPath = await this.#knownStore.dedup(
 			runId,
@@ -593,106 +616,15 @@ export default class TurnExecutor {
 		const { name: _, ...attributes } = cmd;
 		if (cmd.path) attributes.path = target;
 
-		// known tool or naked write → known:// slug from body
-		if (scheme === "known" || (scheme === "set" && !cmd.path)) {
-			if (!cmd.body) return null;
-
-			// Size gate: reject entries > 512 tokens — force atomic entries
-			const entryTokens = countTokens(cmd.body);
-			const MAX_ENTRY_TOKENS = 512;
-			if (scheme === "known" && entryTokens > MAX_ENTRY_TOKENS) {
-				const rejectPath = await this.#knownStore.slugPath(
-					runId,
-					scheme,
-					cmd.body,
-				);
-				await this.#knownStore.upsert(
-					runId,
-					turn,
-					rejectPath,
-					`Entry too large (${entryTokens} tokens, max ${MAX_ENTRY_TOKENS}). Sort the information, ideas, or plans carefully into multiple entries.`,
-					413,
-					{ loopId },
-				);
-				return {
-					scheme,
-					path: rejectPath,
-					body: "",
-					resultPath: rejectPath,
-					attributes,
-					status: 413,
-				};
-			}
-
-			let knownPath = cmd.path;
-			if (!knownPath) {
-				knownPath = await this.#knownStore.slugPath(
-					runId,
-					"known",
-					cmd.body,
-					cmd.summary,
-				);
-			}
-			// Dedup: if this exact path already exists, update rather than duplicate
-			const existing = await this.#knownStore.getEntriesByPattern(
-				runId,
-				knownPath,
-				null,
-			);
-			if (existing.length > 0) {
-				// Path exists — update body and turn, skip creating a new entry
-				await this.#knownStore.upsert(
-					runId,
-					turn,
-					existing[0].path,
-					cmd.body || existing[0].body,
-					200,
-					{
-						loopId,
-					},
-				);
-				return {
-					scheme: "known",
-					path: existing[0].path,
-					body: cmd.body || existing[0].body,
-					resultPath: existing[0].path,
-					attributes,
-				};
-			}
-			await this.#knownStore.upsert(runId, turn, knownPath, cmd.body, 200, {
-				loopId,
-			});
-			return {
-				scheme: "known",
-				path: knownPath,
-				body: cmd.body,
-				resultPath: knownPath,
-				attributes,
-			};
-		}
-
 		const body = cmd.body || cmd.command || cmd.question || "";
 
 		// Filter: plugins can validate/transform before recording
 		const filtered = await this.#hooks.entry.recording.filter(
 			{ scheme, path: resultPath, body, attributes, status: 200 },
-			{ runId, turn, loopId },
+			{ runId, turn, loopId, mode },
 		);
 		if (filtered.status >= 400) return filtered;
 
-		// Record the entry — 200 OK, handlers change status during dispatch
-		await this.#knownStore.upsert(
-			runId,
-			turn,
-			filtered.path,
-			filtered.body,
-			200,
-			{
-				attributes: filtered.attributes,
-				loopId,
-			},
-		);
-
 		return {
 			scheme: filtered.scheme,
 			path: filtered.path,
@@ -702,34 +634,4 @@ export default class TurnExecutor {
 			resultPath: filtered.path,
 		};
 	}
-
-	async #rematerialize(runId, loopId, turn) {
-		await this.#db.clear_turn_context.run({ run_id: runId, turn });
-		const viewRows = await this.#db.get_model_context.all({ run_id: runId });
-		for (const row of viewRows) {
-			const scheme = row.scheme || "file";
-			const projectedBody = await this.#hooks.tools.view(scheme, {
-				path: row.path,
-				scheme,
-				body: row.body,
-				attributes: row.attributes ? JSON.parse(row.attributes) : null,
-				fidelity: row.fidelity,
-				category: row.category,
-			});
-			await this.#db.insert_turn_context.run({
-				run_id: runId,
-				loop_id: loopId,
-				turn,
-				ordinal: row.ordinal,
-				path: row.path,
-				fidelity: row.fidelity,
-				status: row.status,
-				body: projectedBody ?? "",
-				tokens: countTokens(projectedBody ?? ""),
-				attributes: row.attributes,
-				category: row.category,
-				source_turn: row.turn,
-			});
-		}
-	}
 }