@possumtech/rummy 0.4.0 → 0.5.0

package/src/plugins/file/file.js

@@ -16,13 +16,8 @@ export default class File {
 		this.#core = core;
 		// "file" scheme covers bare paths (scheme IS NULL in DB)
 		core.registerScheme({ category: "data" });
-		core.registerScheme({ name: "http", category: "data" });
-		core.registerScheme({ name: "https", category: "data" });
-		core.on("full", this.full.bind(this));
-		core.on("summary", this.summary.bind(this));
-		// Default identity views for http/https — rummy.web overrides these
-		core.hooks.tools.onView("http", (entry) => entry.body);
-		core.hooks.tools.onView("https", (entry) => entry.body);
+		core.on("promoted", this.full.bind(this));
+		core.on("demoted", this.summary.bind(this));
 	}
 
 	full(entry) {

package/src/plugins/get/get.js

@@ -9,8 +9,8 @@ export default class Get {
 		this.#core = core;
 		core.registerScheme();
 		core.on("handler", this.handler.bind(this));
-		core.on("full", this.full.bind(this));
-		core.on("summary", this.summary.bind(this));
+		core.on("promoted", this.full.bind(this));
+		core.on("demoted", this.summary.bind(this));
 		core.filter("instructions.toolDocs", async (docsMap) => {
 			docsMap.get = docs;
 			return docsMap;
@@ -29,6 +29,7 @@ export default class Get {
 		}
 		const normalized = KnownStore.normalizePath(target);
 		const bodyFilter = entry.attributes.body || null;
+		const preview = entry.attributes.preview !== undefined;
 		const isPattern = bodyFilter || normalized.includes("*");
 
 		const line =
@@ -46,6 +47,25 @@ export default class Get {
 			bodyFilter,
 		);
 
+		// Preview — list matches with their full-body token costs. No promotion,
+		// no fidelity change, no Token Budget spent. Model uses this to plan
+		// which entries to actually promote. getDoc promises this behavior; the
+		// prior implementation silently promoted anyway, burning the Token Budget
+		// on entries the model thought it was only inspecting.
+		if (preview) {
+			await storePatternResult(
+				store,
+				runId,
+				turn,
+				"get",
+				target,
+				bodyFilter,
+				matches,
+				{ preview: true, loopId, attributes: { path: target } },
+			);
+			return;
+		}
+
 		// Partial read — no fidelity promotion, returns a line slice as the log item.
 		if (line !== null || limit !== null) {
 			if (isPattern) {
@@ -55,7 +75,7 @@ export default class Get {
 					entry.resultPath,
 					"line/limit requires a single path, not a glob or body filter",
 					400,
-					{ loopId },
+					{ loopId, attributes: { path: target } },
 				);
 				return;
 			}
@@ -66,7 +86,7 @@ export default class Get {
 					entry.resultPath,
 					`${target} not found`,
 					200,
-					{ loopId },
+					{ loopId, attributes: { path: target } },
 				);
 				return;
 			}
@@ -84,15 +104,15 @@ export default class Get {
 				entry.resultPath,
 				`${header}\n${slice}`,
 				200,
-				{ loopId },
+				{ loopId, attributes: { path: target } },
 			);
 			return;
 		}
 
 		const VALID_FIDELITY = {
-			summary: 1,
-			full: 1,
-			archive: 1,
+			demoted: 1,
+			promoted: 1,
+			archived: 1,
 		};
 		const fidelityAttr = VALID_FIDELITY[entry.attributes.fidelity]
 			? entry.attributes.fidelity
@@ -113,17 +133,18 @@ export default class Get {
 				target,
 				bodyFilter,
 				matches,
-				{ loopId },
+				{ loopId, attributes: { path: target } },
 			);
 		} else {
 			const total = matches.reduce((s, m) => s + m.tokens, 0);
 			const paths = matches.map((m) => m.path).join(", ");
 			const body =
 				matches.length > 0
-					? `${paths} promoted to full (${total} tokens)`
+					? `${paths} promoted (${total} tokens)`
 					: `${target} not found`;
 			await store.upsert(runId, turn, entry.resultPath, body, 200, {
 				loopId,
+				attributes: { path: target },
 			});
 		}
 	}

package/src/plugins/get/getDoc.js

@@ -2,43 +2,32 @@
 // Text goes to the model. Rationale stays in source.
 // Changing ANY line requires reading ALL rationales first.
 const LINES = [
-	["## <get>[path/to/file]</get> - Load a file or entry into context"],
-	[
-		"Example: <get>src/app.js</get>",
-		"Simplest form. Body = path.",
-	],
-	[
-		'Example: <get path="known://*">auth</get>',
-		"Keyword recall: glob in path, search term in body.",
-	],
-	[
-		'Example: <get path="src/**/*.js" preview>authentication</get>',
-		"Full pattern: recursive glob + preview + content filter.",
-	],
-	[
-		'Example: <get path="src/agent/AgentLoop.js" line="644" limit="80"/>',
-		"Partial read. Returns lines 644–723 without promoting.",
-	],
-	[
-		"* Paths accept patterns: `src/**/*.js`, `known://api_*`",
-		"Reinforces picomatch patterns work everywhere.",
-	],
-	[
-		"* `preview` lists matches without loading into context",
-		"Budget-awareness. Preview avoids promotion.",
-	],
-	[
-		"* Body text filters results by content match",
-		"Body = filter, not just path.",
-	],
-	[
-		"* `line` and `limit` read a slice without promoting — patterns not allowed",
-		"Partial read is safe: context budget unaffected.",
-	],
-	[
-		'* Use <set path="src/file.txt" fidelity="summary"/> when the content is irrelevant to save tokens.',
-		"Cross-tool lifecycle: get promotes, set demotes.",
-	],
+  ["## <get>[path/to/file]</get> - Promote an entry"],
+  ["Example: <get>src/app.js</get>", "Simplest form. Body = path."],
+  [
+    'Example: <get path="known://*">auth</get>',
+    "Keyword recall: glob in path, search term in body.",
+  ],
+  [
+    'Example: <get path="src/**/*.js">authentication</get>',
+    "Full pattern: recursive glob + content filter.",
+  ],
+  [
+    'Example: <get path="src/agent/AgentLoop.js" line="644" limit="80"/>',
+    "Partial read. Returns lines 644–723 without promoting.",
+  ],
+  [
+    "* Paths accept patterns: `src/**/*.js`, `known://api_*`",
+    "Reinforces picomatch patterns work everywhere.",
+  ],
+  [
+    "* Body text filters results by content match",
+    "Body = filter, not just path.",
+  ],
+  [
+    "* `line` and `limit` read a slice without promoting the entry, which costs as many tokens as the slice contains.",
+    "Partial read is safe: context budget unaffected.",
+  ],
 ];
 
 export default LINES.map(([text]) => text).join("\n");

package/src/plugins/helpers.js

@@ -10,7 +10,7 @@ export async function storePatternResult(
 	path,
 	bodyFilter,
 	matches,
-	{ preview = false, loopId = null } = {},
+	{ preview = false, loopId = null, attributes = null } = {},
 ) {
 	const slug = await store.slugPath(runId, scheme, path);
 	const filter = bodyFilter ? ` body="${bodyFilter}"` : "";
@@ -18,5 +18,5 @@ export async function storePatternResult(
 	const listing = matches.map((m) => `${m.path} (${m.tokens})`).join("\n");
 	const prefix = preview ? "PREVIEW " : "";
 	const body = `${prefix}${scheme} path="${path}"${filter}: ${matches.length} matched (${total} tokens)\n${listing}`;
-	await store.upsert(runId, turn, slug, body, 200, { loopId });
+	await store.upsert(runId, turn, slug, body, 200, { loopId, attributes });
 }

package/src/plugins/instructions/instructions.js

@@ -10,7 +10,7 @@ export default class Instructions {
 
 	constructor(core) {
 		this.#core = core;
-		core.on("full", this.full.bind(this));
+		core.on("promoted", this.full.bind(this));
 		core.on("turn.started", this.onTurnStarted.bind(this));
 	}
 
@@ -33,14 +33,15 @@ export default class Instructions {
 		const activeTools = attrs.toolSet
 			? new Set(attrs.toolSet)
 			: new Set(this.#core.hooks.tools.names);
-		const sorted = this.#core.hooks.tools.names.filter((n) =>
-			activeTools.has(n),
-		);
-		const tools = sorted.join(", ");
 		const toolDocs = await this.#core.hooks.instructions.toolDocs.filter(
 			{},
 			{ toolSet: activeTools },
 		);
+		// Hidden tools are excluded at the registry level (see ToolRegistry).
+		const sorted = this.#core.hooks.tools.advertisedNames.filter((n) =>
+			activeTools.has(n),
+		);
+		const tools = sorted.join(", ");
 		const docsText = sorted
 			.filter((key) => toolDocs[key])
 			.map((key) => toolDocs[key])

package/src/plugins/instructions/preamble.md

@@ -1,37 +1,45 @@
-You are a folksonomic knowledgebase assistant. YOU MUST discern what you don't know into unknowns, then extract and organize your findings into navigable and searchable knowns, then YOU MAY answer questions and/or perform actions.
-
-# Tool Commands
-
-Tools: [%TOOLS%]
-
-# Tool Rules
-
-## Response Rules
-Required: YOU MUST respond with Tool Commands in the XML format. YOU MAY use up to 12 tools in your response.
-Required: YOU MUST register all unknowns with <unknown>[specific thing I need to learn]</unknown>.
-Required: YOU MUST register all new facts, decisions, and plans with <known path="topic/subtopic" summary="keyword,keyword,keyword">[specific facts, decisions, or plans]</known>.
-
-## Folksonomic Memory Management
-* Write paths with navigable hierarchies and summaries with searchable tags.
-* When new facts, decisions, and plans appear, set them as <known/> entries with navigable hierarchies and summaries with searchable tags to improve your folksonomic knowledgebase.
-* When new questions emerge, use pattern matching operations to optimize the fidelity and relevance of your knowledgebase.
-* The turn attribute can be helpful for discerning what's fresh or stale, prefer more recent information if conflicts exist.
-* YOU MUST promote all relevant entries and demote all irrelevant entries before acting or answering. Use body pattern search (Example: <get path="known://*">John Doe</get>) to recall archived entries when needed.
-* Logging entries in <previous/> can also be demoted to optimize context.
-
-## Fidelity Management
-* full: Entire contents are shown (consumes token budget)
-* summary: Only path and summary are shown. (<= 80 chars, saves token budget)
-* archive: Archived in an unlimited archive. Entries can be recalled with path recall or pattern search. (use caution)
-
-## Token Budget Management
-* Entries contain a "fidelity" and a "token" attribute to enable token budget management and context optimization.
-* Set relevant entries to "full" and irrelevant entries to "summary" to optimize context.
-* The less irrelevant information in your context, the better.
-
-## Response Termination
-Required: YOU MUST conclude every turn with EITHER <update></update> if still working OR <summarize></summarize> if done. Never both.
+You are a folksonomic knowledgebase assistant. Define what's unknown, gather knowns to resolve the unknown, act, then answer.
+
+Required: YOU MUST only respond with Tool Commands in the XML format (max 12/turn): [%TOOLS%]
+
+Required: YOU MUST register your unresolved questions as unknown:// entries, then resolve them.
+Example: <set path="unknown://{topic_or_question}" summary="keyword,keyword,keyword">specific question I need to research</set>
+
+Required: YOU MUST gather relevant facts, decisions, and information to store in known:// entries.
+Required: YOU MUST include navigable paths and specific, searchable summary tags to enable pattern search and promotion.
+Example: <set path="known://topic/subtopic1" summary="keyword,keyword,keyword">{known facts, decisions, or plans}</set>
+
+Required: YOU MUST add the paths of related entries to your entry, and edit existing related entries to add linkbacks.
+Example: <set path="known://topic/subtopic2" summary="keyword,keyword,keyword">{facts} Related: known://topic/subtopic1</set>
+
+Required: YOU MUST promote relevant entries to verify their contents. Paths and summaries are approximate and unreliable.
+Example: <get path="facts.txt"/>
+Required: YOU MUST demote entries after organizing and categorizing relevant information into known entries.
+Example: <set path="prompt://42" fidelity="demoted"/>
+
+Required: YOU MUST calculate and estimate the token totals (tokens="N") of entries before promoting and not exceed 50% of Token Budget.
+Warning: Promotions and new entries cost tokens. Demotions recover tokens. Exceeding your budget will result in a 413 Token Budget Error.
+Tip: Entries with higher turn numbers are more recent and relevant.
+
+Required: YOU MUST create and maintain a checklist to guide and track your progress. Only check items when they're completed.
+Required: YOU MUST adapt and expand this checklist for the specific context, entries, and prompt requirements.
+Example:
+<set path="known://rummy_plan" summary="plan,strategy,steps,roadmap">
+- [ ] identify and record unknown facts, unresolved decisions, and unclear plans
+- [ ] identify, organize, and categorize known facts, decisions, and plans before acting on prompt
+- [ ] identify relevant entries to verify, analyze, review, and record contents (don't assume from path or summary!)
+- [ ] after promoting an entry, organize and categorize findings into known entries
+- [ ] after the entry's information has been stored in known entries, demote it to optimize context relevance and token budget
+- [ ] iteratively analyze and explore until the unknowns that can be resolved are resolved
+- [ ] { specific action required by prompt }
+- [ ] ...
+- [ ] summarize when complete with summarize tag
+</set>
+Example: <set path="known://rummy_plan">s/- [ ] specific action required by prompt/- [x] specific action required by prompt/g</set>
 
 # Tool Usage
 
+Warning: YOU MUST NOT use shell commands for file operations. Files are entries that require Tool Command operations.
+Example: <set path="newFile.txt" summary="keyword,keyword,keyword">{new file contents}</set>
+
 [%TOOLDOCS%]

package/src/plugins/known/known.js

@@ -1,5 +1,4 @@
 import { countTokens } from "../../agent/tokens.js";
-import docs from "./knownDoc.js";
 
 const MAX_ENTRY_TOKENS = Number(process.env.RUMMY_MAX_ENTRY_TOKENS) || 512;
 
@@ -10,13 +9,13 @@ export default class Known {
 		this.#core = core;
 		core.registerScheme({ category: "data" });
 		core.on("handler", this.handler.bind(this));
-		core.on("full", this.full.bind(this));
-		core.on("summary", this.summary.bind(this));
+		core.on("promoted", this.full.bind(this));
+		core.on("demoted", this.summary.bind(this));
 		core.filter("assembly.system", this.assembleKnown.bind(this), 100);
-		core.filter("instructions.toolDocs", async (docsMap) => {
-			docsMap.known = docs;
-			return docsMap;
-		});
+		// <known> is internal — written via <set path="known://...">. Hidden
+		// from all model-facing tool lists. Handler still dispatches if the
+		// model emits <known> directly out of habit.
+		core.markHidden();
 	}
 
 	async handler(entry, rummy) {
@@ -73,11 +72,11 @@ export default class Known {
 	}
 
 	full(entry) {
-		return `# known ${entry.path}\n${entry.body}`;
+		return entry.body;
 	}
 
-	summary(entry) {
-		return this.full(entry);
+	summary() {
+		return "";
 	}
 
 	async assembleKnown(content, ctx) {
@@ -103,14 +102,16 @@ function renderKnownTag(entry, demotedSet) {
 		typeof entry.attributes === "string"
 			? JSON.parse(entry.attributes)
 			: entry.attributes;
-	const summary =
+	// Always render summary attribute on knowns — empty value hints the model
+	// it forgot to add searchable keywords.
+	const summaryText =
 		typeof attrs?.summary === "string"
-			? ` summary="${attrs.summary.replace(/"/g, "'").slice(0, 80)}"`
+			? attrs.summary.replace(/"/g, "'").slice(0, 80)
 			: "";
+	const summary = ` summary="${summaryText}"`;
 
-	if (entry.fidelity === "archive") return "";
-	if (entry.fidelity === "summary") {
-		return `<${tag} path="${entry.path}"${turn}${status}${summary}${fidelity}${tokens}${flag}/>`;
+	if (entry.body) {
+		return `<${tag} path="${entry.path}"${turn}${status}${summary}${fidelity}${tokens}${flag}>${entry.body}</${tag}>`;
 	}
-	return `<${tag} path="${entry.path}"${turn}${status}${summary}${fidelity}${tokens}${flag}>${entry.body}</${tag}>`;
+	return `<${tag} path="${entry.path}"${turn}${status}${summary}${fidelity}${tokens}${flag}/>`;
 }

package/src/plugins/known/knownDoc.js

@@ -5,25 +5,13 @@ const LINES = [
 	[
 		'## <known path="known://topic/subtopic" summary="keyword,keyword,keyword">[specific facts, decisions, or plans]</known> - Sort and save what you learn for later recall',
 	],
-	[
-		'Example: <known summary="hedberg,comedian,death,2005">Mitch Hedberg died on March 30, 2005</known>',
-		"Summary-first pattern: comma-separated keywords, path auto-generated.",
-	],
 	[
 		'Example: <known path="known://people/rumsfeld" summary="defense,secretary,born,1932">Donald Rumsfeld was born in 1932 and served as Secretary of Defense</known>',
 		"Explicit path form: slashed path=category/key, summary=keywords.",
 	],
 	[
 		'* Recall with <get path="known://people/*">keyword</get>',
-		"Cross-tool lifecycle: glob by category, filter by keyword.",
-	],
-	[
-		"* YOU SHOULD write `summary` keywords, you can search for them later",
-		"Motivates summary writing through self-interest.",
-	],
-	[
-		"* YOU MUST sort and save all new facts, decisions, and plans in their own <known> entries",
-		"Critical behavioral constraint. 'new' prevents re-saving known facts.",
+		"Cross-tool lifecycle: pattern by category, filter by keyword.",
 	],
 ];
 

package/src/plugins/mv/mv.js

@@ -8,8 +8,8 @@ export default class Mv {
 		this.#core = core;
 		core.registerScheme();
 		core.on("handler", this.handler.bind(this));
-		core.on("full", this.full.bind(this));
-		core.on("summary", this.summary.bind(this));
+		core.on("promoted", this.full.bind(this));
+		core.on("demoted", this.summary.bind(this));
 		core.filter("instructions.toolDocs", async (docsMap) => {
 			docsMap.mv = docs;
 			return docsMap;
@@ -29,14 +29,14 @@ export default class Mv {
 			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}`;
+			const label = `set to ${fidelity}`;
 			await store.upsert(
 				runId,
 				turn,
 				entry.resultPath,
 				`${matches.map((m) => m.path).join(", ")} ${label}`,
 				200,
-				{ fidelity: "archive", loopId },
+				{ fidelity: "archived", loopId },
 			);
 			return;
 		}
@@ -71,7 +71,7 @@ export default class Mv {
 		return `# mv ${entry.attributes.from || ""} ${entry.attributes.to || ""}`;
 	}
 
-	summary(entry) {
-		return this.full(entry);
+	summary() {
+		return "";
 	}
 }

package/src/plugins/mv/mvDoc.js

@@ -9,22 +9,11 @@ const LINES = [
 		'Example: <mv path="known://active_task">known://completed_task</mv>',
 		"Entry rename. Most common mv use case.",
 	],
+	['Example: <mv path="src/old_name.js">src/new_name.js</mv>', "File rename."],
 	[
-		'Example: <mv path="src/old_name.js">src/new_name.js</mv>',
-		"File rename.",
-	],
-	[
-		'Example: <mv path="known://project/*" fidelity="summary"/>',
+		'Example: <mv path="known://project/*" fidelity="demoted"/>',
 		"Batch fidelity change via pattern. No destination = fidelity in place.",
 	],
-	[
-		"* Source path accepts patterns for batch moves",
-		"Pattern support consistent with get/cp/rm.",
-	],
-	[
-		"* Use `preview` to check matches before pattern-based bulk moves",
-		"Safety pattern consistent with rm/cp.",
-	],
 ];
 
 export default LINES.map(([text]) => text).join("\n");

package/src/plugins/previous/previous.js

@@ -43,18 +43,14 @@ async function renderToolTag(entry, _core) {
 	const status = entry.status ? ` status="${entry.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}/>`;
+	const summary =
+		typeof attrs?.summary === "string"
+			? ` summary="${attrs.summary.replace(/"/g, "'")}"`
+			: "";
+
+	// Trust the projected body. Plugin decided per-fidelity what to show.
+	if (entry.body) {
+		return `<${entry.scheme} path="${target}"${turn}${status}${summary}${fidelity}${tokens}>${entry.body}</${entry.scheme}>`;
+	}
+	return `<${entry.scheme} path="${target}"${turn}${status}${summary}${fidelity}${tokens}/>`;
 }

package/src/plugins/progress/progress.js

@@ -1,3 +1,6 @@
+const CEILING_RATIO = Number(process.env.RUMMY_BUDGET_CEILING);
+if (!CEILING_RATIO) throw new Error("RUMMY_BUDGET_CEILING must be set");
+
 export default class Progress {
 	#core;
 
@@ -7,17 +10,31 @@ export default class Progress {
 	}
 
 	async assembleProgress(content, ctx) {
-		const { lastContextTokens: usedTokens, contextSize } = ctx;
-		const pct = contextSize ? Math.round((usedTokens / contextSize) * 100) : 0;
-
+		const { rows, contextSize, baselineTokens } = ctx;
 		const lines = [];
+
 		if (contextSize) {
+			const ceiling = Math.floor(contextSize * CEILING_RATIO);
+			const tokenBudget = Math.max(0, ceiling - (baselineTokens || 0));
+			// Used = sum of promoted controllable entries' tokens. Same units as
+			// per-entry tokens="N" so the model can predict the effect of a
+			// promote/demote: change is exactly the entry's tokens attribute.
+			const used = rows.reduce((sum, r) => {
+				if (
+					(r.category === "data" || r.category === "logging") &&
+					r.fidelity === "promoted"
+				) {
+					return sum + (r.tokens || 0);
+				}
+				return sum;
+			}, 0);
+			const remaining = Math.max(0, tokenBudget - used);
 			lines.push(
-				`Using ${usedTokens} tokens (${pct}%) of ${contextSize} token budget. Use <get/> or set entry fidelity to "full" to spend tokens. Set entry fidelity to "summary" to save tokens.`,
+				`Token Budget: ${tokenBudget}. Using ${used}. ${remaining} remaining. Promote relevant entries with <get/> to spend. Demote irrelevant entries with <set fidelity="demoted"/> to save.`,
 			);
 		}
 		lines.push(
-			'Conclude with a brief <update></update> to continue or a brief <summarize></summarize> if done.',
+			"Conclude with a brief <update></update> to continue or a brief <summarize></summarize> if done.",
 		);
 		const body = lines.join("\n");
 

package/src/plugins/prompt/prompt.js

@@ -3,16 +3,18 @@ export default class Prompt {
 
 	constructor(core) {
 		this.#core = core;
-		core.hooks.tools.onView("prompt", (entry) => {
-			if (entry.fidelity === "summary") {
+		core.hooks.tools.onView("prompt", (entry) => entry.body, "promoted");
+		core.hooks.tools.onView(
+			"prompt",
+			(entry) => {
 				const limit = 500;
 				const text = entry.body?.slice(0, limit) || "";
 				return text.length < (entry.body?.length || 0)
-					? `${text}\n[truncated — promote to full to see the complete prompt]`
+					? `${text}\n[truncated — promote to see the complete prompt]`
 					: text;
-			}
-			return entry.body;
-		});
+			},
+			"demoted",
+		);
 		core.on("turn.started", this.onTurnStarted.bind(this));
 		core.filter("assembly.user", this.assemblePrompt.bind(this), 300);
 	}
@@ -39,13 +41,14 @@ export default class Prompt {
 				: promptEntry?.attributes;
 		const mode = attrs?.mode || ctx.type;
 		const body = promptEntry?.body || "";
-		const toolNames = ctx.toolSet
-			? [...ctx.toolSet]
-			: [...this.#core.hooks.tools.resolveForLoop(mode)];
-		const tools = toolNames.join(",");
+		// No tools="..." attribute. The OpenAI-shaped
+		// `<prompt mode tools="x,y,z">` rendering was priming gemma's
+		// native-tool-call training prior — A/B test confirmed removing
+		// the attribute dropped native-format emissions from ~50% to 0%.
+		// Tools list lives in the system prompt as "XML Command Tools:".
 		let warn = "";
 		if (mode === "ask") warn = ' warn="File editing disallowed."';
 
-		return `${content}<prompt mode="${mode}" tools="${tools}"${warn}>${body}</prompt>`;
+		return `${content}<prompt mode="${mode}"${warn}>${body}</prompt>`;
 	}
 }

package/src/plugins/rm/rm.js

@@ -8,8 +8,8 @@ export default class Rm {
 		this.#core = core;
 		core.registerScheme();
 		core.on("handler", this.handler.bind(this));
-		core.on("full", this.full.bind(this));
-		core.on("summary", this.summary.bind(this));
+		core.on("promoted", this.full.bind(this));
+		core.on("demoted", this.summary.bind(this));
 		core.filter("instructions.toolDocs", async (docsMap) => {
 			docsMap.rm = docs;
 			return docsMap;
@@ -74,7 +74,7 @@ export default class Rm {
 		return entry.body ? `${header}\n${entry.body}` : header;
 	}
 
-	summary(entry) {
-		return this.full(entry);
+	summary() {
+		return "";
 	}
 }

package/src/plugins/rm/rmDoc.js

@@ -4,21 +4,17 @@
 const LINES = [
 	['## <rm path="[path]"/> - Remove a file or entry'],
 	['Example: <rm path="src/config.js"/>', "File removal. Simplest form."],
-	[
-		'Example: <rm path="known://config/deprecated_service"/>',
-		"Shows topic-hierarchy path convention.",
-	],
 	[
 		'Example: <rm path="known://temp_*" preview/>',
 		"Preview before deleting. Safety pattern for bulk operations.",
 	],
 	[
-		'* Permanent. Prefer <set fidelity="archive"/> to preserve for later retrieval',
-		"Nudges toward archive over rm.",
+		'* Permanent. Prefer <set path="..." fidelity="archived"/> to preserve for later retrieval',
+		"Nudges toward archive over rm. Path attr included so the model sees a complete invocation shape, not a fragment.",
 	],
 	[
-		"* Use `preview` to check matches before pattern-based bulk deletion",
-		"Reinforces preview safety pattern.",
+		"* `preview` shows what paths would be affected without performing the operation.",
+		"Canonical preview teaching lives here — rm is the most intuitive 'check before committing' case. Model generalizes to cp/mv/get by analogy. Advanced uses (e.g. archive rediscovery via <get preview>) belong in persona/skill docs, not here.",
 	],
 ];