@possumtech/rummy 0.2.8 → 0.3.1

package/src/plugins/known/README.md

@@ -1,18 +1,21 @@
 # known
 
-Writes arbitrary key/value entries into the store at full fidelity.
+Writes knowledge entries into the store at full fidelity.
 
 ## Registration
 
 - **Tool**: `known`
-- **Modes**: ask, act
-- **Category**: act
-- **Handler**: Upserts the entry body at the target path with `full` state.
+- **Category**: `data`
+- **Handler**: Upserts the entry body at the target path with status 200.
+- **Filter**: `assembly.system` at priority 100 — renders `<knowns>` section.
 
 ## Projection
 
-Shows `known {path}` followed by the entry body.
+Shows `# known {path}` followed by the entry body.
 
-## Behavior
+## Assembly
 
-The target path defaults to `entry.resultPath` but can be overridden via `attrs.path`. Used by the model to persist structured notes and context.
+Filters turn_context rows where `category === "data"`. Renders all
+data entries (files, knowledge, skills, URLs) into the `<knowns>` section
+of the system message. Third-party plugins that register with
+`category: "data"` automatically appear here.

package/src/plugins/known/known.js

@@ -1,24 +1,24 @@
-import { readFileSync } from "node:fs";
+import docs from "./knownDoc.js";
 
 export default class Known {
 	#core;
 
 	constructor(core) {
 		this.#core = core;
-		core.registerScheme({ category: "knowledge" });
+		core.registerScheme({ category: "data" });
 		core.on("handler", this.handler.bind(this));
 		core.on("full", this.full.bind(this));
 		core.filter("assembly.system", this.assembleKnown.bind(this), 100);
-		const docs = readFileSync(new URL("./docs.md", import.meta.url), "utf8");
-		core.filter("instructions.toolDocs", async (content) =>
-			content ? `${content}\n\n${docs}` : docs,
-		);
+		core.filter("instructions.toolDocs", async (docsMap) => {
+			docsMap.known = docs;
+			return docsMap;
+		});
 	}
 
 	async handler(entry, rummy) {
-		const { entries: store, sequence: turn, runId } = rummy;
+		const { entries: store, sequence: turn, runId, loopId } = rummy;
 		const target = entry.attributes.path || entry.resultPath;
-		await store.upsert(runId, turn, target, entry.body, 200);
+		await store.upsert(runId, turn, target, entry.body, 200, { loopId });
 	}
 
 	full(entry) {
@@ -26,13 +26,7 @@ export default class Known {
 	}
 
 	async assembleKnown(content, ctx) {
-		const entries = ctx.rows.filter(
-			(r) =>
-				r.category === "file" ||
-				r.category === "file_index" ||
-				r.category === "known" ||
-				r.category === "known_index",
-		);
+		const entries = ctx.rows.filter((r) => r.category === "data");
 		if (entries.length === 0) return content;
 
 		// Rows arrive pre-sorted by SQL: skill → index → summary → full, then by recency
@@ -43,13 +37,25 @@ export default class Known {
 }
 
 function renderKnownTag(entry, demotedSet) {
+	const tag = entry.scheme || "file";
+	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
 	const tokens = entry.tokens ? ` tokens="${entry.tokens}"` : "";
 	const status = entry.status ? ` status="${entry.status}"` : "";
+	const fidelity = entry.fidelity ? ` fidelity="${entry.fidelity}"` : "";
 	const flag = demotedSet?.has(entry.path) ? " demoted" : "";
 
+	const attrs =
+		typeof entry.attributes === "string"
+			? JSON.parse(entry.attributes)
+			: entry.attributes;
+	const summary =
+		typeof attrs?.summary === "string"
+			? ` summary="${attrs.summary.slice(0, 80)}"`
+			: "";
+
 	if (entry.body) {
-		return `<known path="${entry.path}"${status}${tokens}${flag}>${entry.body}</known>`;
+		return `<${tag} path="${entry.path}"${turn}${status}${fidelity}${summary}${tokens}${flag}>${entry.body}</${tag}>`;
 	}
 
-	return `<known path="${entry.path}"${status}${tokens}${flag}/>`;
+	return `<${tag} path="${entry.path}"${turn}${status}${fidelity}${summary}${tokens}${flag}/>`;
 }

package/src/plugins/known/knownDoc.js

@@ -0,0 +1,34 @@
+// Tool doc for <known/>. Each entry: [text, rationale].
+// Text goes to the model. Rationale stays in source.
+// Changing ANY line requires reading ALL rationales first.
+const LINES = [
+	// --- Syntax: path = slash-separated topic hierarchy, body = the information to save
+	[
+		'## <known path="known://topic/subtopic" summary="keyword,keyword,keyword">[specific facts, decisions, or plans]</known> - Sort and save what you learn for later recall',
+	],
+	// --- Examples: category-level entries — multiple related facts per entry, not one per item
+	[
+		'Example: <known path="known://config/database" summary="database,host,port,pool,replica">Host: db.internal. Port: 5432. Pool: 10 connections. Replica: db-replica.internal:5432.</known>',
+		"Category entry: all database config facts in one entry. Path is an address (topic/subtopic), body collects every related fact, summary is comma-separated search keywords — not a description.",
+	],
+	[
+		'Example: <known path="known://project/milestones" summary="milestone,deadline,alpha,launch,2026">Alpha: 2026-03-01. Beta cutoff: 2026-04-15. GA launch: 2026-06-01.</known>',
+		"Timeline entry: all milestone dates under one path. Multiple facts per entry reduces fragmentation. Recall by glob or keyword.",
+	],
+	// --- Constraints: summary and grouping first (model forms generation pattern from header + examples)
+	[
+		"* `summary` REQUIRED — at summary fidelity the body is hidden; these keywords are your only description",
+		"Self-interest framing: without summary, the model has a path but no idea what's inside.",
+	],
+	[
+		"* Group related facts by topic — one entry per topic category, not one per input chunk",
+		"Critical behavioral constraint. Topic grouping enables semantic recall; chunk-based filing creates positional, irretrievable entries.",
+	],
+	// --- Lifecycle
+	[
+		'* Recall with <get path="known://config/*">replica</get>',
+		"Cross-tool lifecycle: glob by category, filter by keyword. Matches the slashed path convention.",
+	],
+];
+
+export default LINES.map(([text]) => text).join("\n");

package/src/plugins/mv/README.md

@@ -5,9 +5,8 @@ Moves (renames) an entry from one path to another within the K/V store.
 ## Registration
 
 - **Tool**: `mv`
-- **Modes**: ask, act
-- **Category**: act
-- **Handler**: Reads source body, writes to destination, removes source. K/V destinations resolve immediately (`pass`); file destinations produce a `proposed` entry.
+- **Category**: `logging`
+- **Handler**: Reads source body, writes to destination, removes source. Scheme destinations resolve immediately (status 200); file destinations produce status 202 (proposed).
 
 ## Projection
 
@@ -15,4 +14,6 @@ Shows `mv {from} {to}`.
 
 ## Behavior
 
-Warns if the destination already exists and will be overwritten. Uses `KnownStore.scheme()` to determine K/V vs file paths. Source entry is removed on successful K/V moves.
+Warns if the destination already exists and will be overwritten. Uses
+`KnownStore.scheme()` to determine scheme vs file paths. Source entry
+is removed on successful scheme moves.

package/src/plugins/mv/mv.js

@@ -1,5 +1,5 @@
-import { readFileSync } from "node:fs";
 import KnownStore from "../../agent/KnownStore.js";
+import docs from "./mvDoc.js";
 
 export default class Mv {
 	#core;
@@ -10,15 +10,36 @@ export default class Mv {
 		core.on("handler", this.handler.bind(this));
 		core.on("full", this.full.bind(this));
 		core.on("summary", this.summary.bind(this));
-		const docs = readFileSync(new URL("./docs.md", import.meta.url), "utf8");
-		core.filter("instructions.toolDocs", async (content) =>
-			content ? `${content}\n\n${docs}` : docs,
-		);
+		core.filter("instructions.toolDocs", async (docsMap) => {
+			docsMap.mv = docs;
+			return docsMap;
+		});
 	}
 
 	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, archive: 1 };
+		const fidelity = VALID[entry.attributes.fidelity]
+			? entry.attributes.fidelity
+			: undefined;
+
+		// Fidelity-in-place: no destination, change visibility of matched entries
+		if (fidelity && !to) {
+			const matches = await store.getEntriesByPattern(runId, path);
+			for (const match of matches)
+				await store.setFidelity(runId, match.path, fidelity);
+			const label = fidelity === "archive" ? "archived" : `set to ${fidelity}`;
+			await store.upsert(
+				runId,
+				turn,
+				entry.resultPath,
+				`${matches.map((m) => m.path).join(", ")} ${label}`,
+				200,
+				{ fidelity: "archive", loopId },
+			);
+			return;
+		}
 
 		const source = await store.getBody(runId, path);
 		if (source === null) return;
@@ -37,7 +58,7 @@ export default class Mv {
 				loopId,
 			});
 		} else {
-			await store.upsert(runId, turn, to, source, 200, { loopId });
+			await store.upsert(runId, turn, to, source, 200, { fidelity, loopId });
 			await store.remove(runId, path);
 			await store.upsert(runId, turn, entry.resultPath, body, 200, {
 				attributes: { from: path, to, isMove: true, warning },

package/src/plugins/mv/mvDoc.js

@@ -0,0 +1,45 @@
+// Tool doc for <mv>. Each entry: [text, rationale].
+// Text goes to the model. Rationale stays in source.
+// Changing ANY line requires reading ALL rationales first.
+const LINES = [
+	// --- Syntax: path attr = source, body = destination
+	[
+		'## <mv path="[source]">[destination]</mv> - Move or rename a file or entry',
+	],
+
+	// --- Examples: entry rename and file move
+	[
+		'Example: <mv path="known://active_task">known://completed_task</mv>',
+		"Entry rename. Most common mv use case. Shows known:// path convention.",
+	],
+	[
+		'Example: <mv path="src/old_name.js">src/new_name.js</mv>',
+		"File rename. Shows that mv works on files too, not just known entries.",
+	],
+
+	// --- Archive lifecycle
+	[
+		"* You may move entries or pattern-matching batches of entries to and from the archive to manage your context budget.",
+		"Teaches archival as a reversible budget operation, not permanent deletion.",
+	],
+	[
+		'Example: <mv path="known://project/*" fidelity="index"/> ... <mv path="known://project/active_sprint" fidelity="full"/>',
+		"Index a whole category to free context while keeping paths visible, restore one entry when needed. No destination = fidelity change in place.",
+	],
+	[
+		"* YOU SHOULD demote irrelevant entries to `index` or `archive` — clean context improves reasoning.",
+		"Core curation principle: clean context is a quality signal, not just a budget concern. Teach the model to curate eagerly.",
+	],
+
+	// --- Constraints
+	[
+		"* Source path accepts patterns for batch moves",
+		"Pattern support consistent with get/cp/rm.",
+	],
+	[
+		"* In ask mode, destination MUST be a scheme path (not a file)",
+		"Mode constraint. Prevents file mutations in ask mode via mv.",
+	],
+];
+
+export default LINES.map(([text]) => text).join("\n");

package/src/plugins/performed/README.md

@@ -0,0 +1,15 @@
+# performed
+
+Renders the `<performed>` section of the user message — the active loop's
+tool results and lifecycle signals.
+
+## Registration
+
+- **Filter**: `assembly.user` at priority 100
+
+## Behavior
+
+Filters turn_context rows where `category === "logging"` and
+`source_turn >= loopStartTurn`. Renders each entry chronologically
+with turn, status, summary, fidelity, and tokens. Empty on the first
+turn of a loop.

package/src/plugins/performed/performed.js

@@ -0,0 +1,45 @@
+export default class Performed {
+	#core;
+
+	constructor(core) {
+		this.#core = core;
+		core.filter("assembly.user", this.assemblePerformed.bind(this), 100);
+	}
+
+	async assemblePerformed(content, ctx) {
+		const entries = ctx.rows.filter(
+			(r) =>
+				r.category === "logging" &&
+				r.source_turn >= ctx.loopStartTurn &&
+				r.scheme !== "unknown",
+		);
+		if (entries.length === 0) return content;
+
+		const lines = entries.map((e) => renderToolTag(e));
+		return `${content}<performed>\n${lines.join("\n")}\n</performed>\n`;
+	}
+}
+
+function renderToolTag(entry) {
+	const attrs =
+		typeof entry.attributes === "string"
+			? JSON.parse(entry.attributes)
+			: entry.attributes;
+
+	const target = attrs?.path || attrs?.file || attrs?.command || "";
+	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
+	const status = entry.status ? ` status="${entry.status}"` : "";
+	const fidelity = entry.fidelity ? ` fidelity="${entry.fidelity}"` : "";
+	const tokens = entry.tokens ? ` tokens="${entry.tokens}"` : "";
+	const summary =
+		typeof attrs?.summary === "string"
+			? ` summary="${attrs.summary.slice(0, 80)}"`
+			: "";
+
+	const body = entry.body || null;
+
+	if (body) {
+		return `<${entry.scheme} path="${target}"${turn}${status}${summary}${fidelity}${tokens}>${body}</${entry.scheme}>`;
+	}
+	return `<${entry.scheme} path="${target}"${turn}${status}${summary}${fidelity}${tokens}/>`;
+}

package/src/plugins/persona/persona.js

@@ -0,0 +1,78 @@
+import fs from "node:fs/promises";
+import { join } from "node:path";
+
+export default class Persona {
+	#core;
+
+	constructor(core) {
+		this.#core = core;
+		const r = core.hooks.rpc.registry;
+
+		r.register("persona/set", {
+			handler: async (params, ctx) => {
+				if (!params.run) throw new Error("run is required");
+
+				const runRow = await ctx.db.get_run_by_alias.get({ alias: params.run });
+				if (!runRow) throw new Error(`Run not found: ${params.run}`);
+
+				let text = params.text;
+				if (params.name && !text) {
+					text = await loadFile(params.name);
+				}
+
+				await ctx.db.update_run_config.run({
+					id: runRow.id,
+					temperature: null,
+					persona: text || null,
+					context_limit: null,
+					model: null,
+				});
+
+				return { status: "ok" };
+			},
+			description:
+				"Set persona on a run. Pass name or text. Pass neither to clear.",
+			params: {
+				run: "string — run alias",
+				name: "string? — persona filename (without .md)",
+				text: "string? — raw persona text (overrides name)",
+			},
+			requiresInit: true,
+		});
+
+		r.register("listPersonas", {
+			handler: async () => {
+				const dir = configDir();
+				if (!dir) return [];
+				try {
+					const files = await fs.readdir(dir);
+					return files
+						.filter((f) => f.endsWith(".md"))
+						.map((f) => ({ name: f.replace(".md", ""), path: join(dir, f) }));
+				} catch {
+					return [];
+				}
+			},
+			description: "List available persona files. Returns [{ name, path }].",
+			requiresInit: true,
+		});
+	}
+}
+
+function configDir() {
+	const home = process.env.RUMMY_HOME;
+	if (home) return join(home, "personas");
+	return null;
+}
+
+async function loadFile(name) {
+	const dir = configDir();
+	if (!dir) throw new Error("RUMMY_HOME not configured");
+	const path = join(dir, `${name}.md`);
+	try {
+		return await fs.readFile(path, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") throw new Error(`Not found: ${path}`);
+		throw err;
+	}
+}

package/src/plugins/previous/README.md

@@ -10,6 +10,7 @@ history from prior ask/act invocations on this run.
 
 ## Behavior
 
-Filters turn_context rows where `category` is `result` or `structural`
+Filters turn_context rows where `category` is `logging` or `prompt`
 and `source_turn < loopStartTurn`. Renders each entry chronologically
-with status symbols (✓/✗/·).
+with turn, status, summary, fidelity, and tokens. The model can target
+these entries by path with `<set>` or `<rm>` to free context space.

package/src/plugins/previous/previous.js

@@ -9,13 +9,20 @@ export default class Previous {
 	async assemblePrevious(content, ctx) {
 		if (ctx.loopStartTurn <= 1) return content;
 
-		const entries = ctx.rows.filter(
-			(r) =>
-				(r.category === "result" ||
-					r.category === "structural" ||
-					r.category === "prompt") &&
-				r.source_turn < ctx.loopStartTurn,
-		);
+		const entries = ctx.rows
+			.filter(
+				(r) =>
+					(r.category === "logging" || r.category === "prompt") &&
+					r.source_turn < ctx.loopStartTurn,
+			)
+			.toSorted((a, b) => {
+				if (a.source_turn !== b.source_turn)
+					return a.source_turn - b.source_turn;
+				// Within the same turn: prompt first (cause before effect)
+				if (a.category === "prompt" && b.category !== "prompt") return -1;
+				if (b.category === "prompt" && a.category !== "prompt") return 1;
+				return 0;
+			});
 		if (entries.length === 0) return content;
 
 		const lines = await Promise.all(
@@ -25,27 +32,29 @@ export default class Previous {
 	}
 }
 
-async function renderToolTag(entry, core) {
+async function renderToolTag(entry, _core) {
 	const attrs =
 		typeof entry.attributes === "string"
 			? JSON.parse(entry.attributes)
 			: entry.attributes;
 
-	const path = `${entry.scheme}://${attrs?.path || attrs?.file || attrs?.command || ""}`;
+	const target = attrs?.path || attrs?.file || attrs?.command || "";
+	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
 	const status = entry.status ? ` status="${entry.status}"` : "";
-
-	let body;
-	try {
-		body = await core.hooks.tools.view(entry.scheme, {
-			...entry,
-			attributes: attrs,
-		});
-	} catch {
-		body = entry.body;
-	}
-
-	if (body) {
-		return `<tool path="${path}"${status}>${body}</tool>`;
-	}
-	return `<tool path="${path}"${status}/>`;
+	const fidelity = entry.fidelity ? ` fidelity="${entry.fidelity}"` : "";
+	const tokens = entry.tokens ? ` tokens="${entry.tokens}"` : "";
+
+	// Previous entries render at summary. Prompts get 512 chars for orientation.
+	const limit = entry.scheme === "prompt" ? 512 : 80;
+	const rawSummary =
+		(typeof attrs?.summary === "string" ? attrs.summary : null) ||
+		entry.body?.slice(0, limit) ||
+		"";
+	// Strip internal dedup namespace prefixes (e.g. "get://turn_3/src/app.js" → "src/app.js")
+	const summaryText = rawSummary.replace(/\b\w+:\/\/turn_\d+\//g, "");
+	const summaryAttr = summaryText
+		? ` summary="${summaryText.replace(/"/g, "'").slice(0, limit)}"`
+		: "";
+
+	return `<${entry.scheme} path="${target}"${turn}${status}${summaryAttr}${fidelity}${tokens}/>`;
 }

package/src/plugins/progress/README.md

@@ -9,9 +9,8 @@ current work log to the active prompt.
 
 ## Behavior
 
-On first turn: "Begin."
+Emits `<progress turn="N">` carrying token budget and fidelity stats.
 On continuation turns with current entries: "The above actions were
 performed in response to the following prompt:"
-If a `progress://` entry exists, uses its body directly.
 
 Progress text is the tuning knob for model orientation between turns.

package/src/plugins/progress/progress.js

@@ -7,44 +7,56 @@ export default class Progress {
 	}
 
 	async assembleProgress(content, ctx) {
-		const usedTokens = ctx.rows.reduce((sum, r) => sum + (r.tokens || 0), 0);
-		const contextSize = ctx.contextSize || 0;
+		const { lastContextTokens: usedTokens, contextSize } = ctx;
 		const pct = contextSize ? Math.round((usedTokens / contextSize) * 100) : 0;
 
+		// Fidelity distribution across all manageable entries (data + logging)
+		const dataEntries = ctx.rows.filter((r) => r.category === "data");
+		const loggingEntries = ctx.rows.filter((r) => r.category === "logging");
+		const entries = [...dataEntries, ...loggingEntries];
+		const fullEntries = entries.filter((r) => r.fidelity === "full");
+		const summaryEntries = entries.filter((r) => r.fidelity === "summary");
+		const indexEntries = entries.filter((r) => r.fidelity === "index");
+		const fullTokens = fullEntries.reduce((s, r) => s + r.tokens, 0);
+		const summaryTokens = summaryEntries.reduce((s, r) => s + r.tokens, 0);
+		const indexTokens = indexEntries.reduce((s, r) => s + r.tokens, 0);
+
 		const unknownCount = ctx.rows.filter(
 			(r) => r.category === "unknown",
 		).length;
 
-		const hasCurrent = ctx.rows.some(
-			(r) =>
-				(r.category === "result" || r.category === "structural") &&
-				r.source_turn >= ctx.loopStartTurn,
+		const hasPerformed = loggingEntries.some(
+			(r) => r.source_turn >= ctx.loopStartTurn,
 		);
 
 		const parts = [];
 
-		const tokenInfo = contextSize
-			? `${usedTokens} of ${contextSize} tokens (${pct}%)`
+		const knownCount = dataEntries.length;
+		const loggingCount = loggingEntries.length;
+		const tokenLine = contextSize
+			? `${usedTokens} of ${contextSize} tokens (${pct}%) · ${knownCount} known${knownCount !== 1 ? "s" : ""} · ${loggingCount} logging · ${unknownCount} unknown${unknownCount !== 1 ? "s" : ""}`
 			: "";
-		const unknownInfo =
-			unknownCount > 0
-				? `${unknownCount} unknown${unknownCount > 1 ? "s" : ""} remaining`
-				: "0 unknowns";
-		const status = [tokenInfo, unknownInfo].filter(Boolean).join(" · ");
-		if (status) parts.push(status);
-
-		if (ctx.demoted?.length > 0) {
-			parts.push(
-				`⚠ ${ctx.demoted.length} entries demoted to summary to fit context budget. Use <get/> to restore.`,
+		if (tokenLine) parts.push(tokenLine);
+
+		// Fidelity distribution
+		const fidelityParts = [];
+		if (fullEntries.length > 0)
+			fidelityParts.push(`${fullEntries.length} full (${fullTokens} tok)`);
+		if (summaryEntries.length > 0)
+			fidelityParts.push(
+				`${summaryEntries.length} summary (${summaryTokens} tok)`,
 			);
-		}
+		if (indexEntries.length > 0)
+			fidelityParts.push(`${indexEntries.length} index (${indexTokens} tok)`);
+		if (fidelityParts.length > 0)
+			parts.push(`Entries: ${fidelityParts.join(" · ")}`);
 
-		if (hasCurrent) {
+		if (hasPerformed) {
 			parts.push(
 				"The above actions were performed in response to the following prompt:",
 			);
 		}
 
-		return `${content}<progress>${parts.join("\n")}</progress>\n`;
+		return `${content}<progress turn="${ctx.turn}">${parts.join("\n")}</progress>\n`;
 	}
 }

package/src/plugins/prompt/README.md

@@ -1,6 +1,6 @@
 # prompt
 
-Renders the `<ask>` or `<act>` tag at the end of the user message.
+Renders the `<prompt mode="ask|act">` tag at the end of the user message.
 Always present on every turn — the model always sees its task.
 
 ## Registration
@@ -9,8 +9,8 @@ Always present on every turn — the model always sees its task.
 
 ## Behavior
 
-Finds the latest `ask://` or `act://` entry in the turn_context rows.
-Renders with `tools` attribute (available tool list) and optional `warn`
-attribute in ask mode ("File and system modification prohibited on this
-turn."). Falls back to the mode passed by the core if no prompt entry
+Finds the latest `prompt://` entry in the turn_context rows. The mode
+(`ask` or `act`) is stored in `attributes.mode`. Renders with `tools`
+attribute (available tool list) and optional `warn` attribute in ask
+mode. Falls back to the mode passed by the core if no prompt entry
 exists.

package/src/plugins/prompt/prompt.js

@@ -3,6 +3,7 @@ export default class Prompt {
 
 	constructor(core) {
 		this.#core = core;
+		core.hooks.tools.onView("prompt", (entry) => entry.body);
 		core.on("turn.started", this.onTurnStarted.bind(this));
 		core.filter("assembly.user", this.assemblePrompt.bind(this), 300);
 	}
@@ -11,34 +12,31 @@ export default class Prompt {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 
 		if (!isContinuation && prompt) {
-			await store.upsert(runId, turn, `prompt://${turn}`, "", 200, {
+			await store.upsert(runId, turn, `prompt://${turn}`, prompt, 200, {
 				attributes: { mode },
 				loopId,
 			});
-			await store.upsert(runId, turn, `${mode}://${turn}`, prompt, 200, {
-				loopId,
-			});
-		} else {
-			await store.upsert(runId, turn, `progress://${turn}`, prompt || "", 200, {
-				loopId,
-			});
 		}
 	}
 
 	async assemblePrompt(content, ctx) {
 		const promptEntry = ctx.rows.findLast(
-			(r) =>
-				r.category === "prompt" && (r.scheme === "ask" || r.scheme === "act"),
+			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
 
-		const mode = promptEntry?.scheme || ctx.type;
+		const attrs =
+			typeof promptEntry?.attributes === "string"
+				? JSON.parse(promptEntry.attributes)
+				: promptEntry?.attributes;
+		const mode = attrs?.mode || ctx.type;
 		const body = promptEntry?.body || "";
-		const tools = this.#core.hooks.tools.namesForMode(mode).join(", ");
-		const warn =
-			mode === "ask"
-				? ' warn="File and system modification prohibited on this turn."'
-				: "";
+		const toolNames = ctx.toolSet
+			? [...ctx.toolSet]
+			: [...this.#core.hooks.tools.resolveForLoop(mode)];
+		const tools = toolNames.join(",");
+		let warn = "";
+		if (mode === "ask") warn = ' warn="File editing disallowed."';
 
-		return `${content}<${mode} tools="${tools}"${warn}>${body}</${mode}>`;
+		return `${content}<prompt mode="${mode}" tools="${tools}"${warn}>${body}</prompt>`;
 	}
 }