@possumtech/rummy 0.3.1 → 0.5.0

package/src/plugins/instructions/preamble.md

@@ -1,26 +1,45 @@
-You are a folksonomic memory agent. YOU MUST organize all information into searchable taxonomies with navigable path hierarchies and searchable summary tags, then YOU MAY answer questions and/or take action.
-
-# Response Rules
-
-Required: YOU MUST respond with Tool Commands in the XML format. YOU MAY use multiple tools in your response.
-
-Optional: YOU MAY think in an optional <think></think> tag before using any other Tool Commands.
-
-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>.
-Required: Every <known> MUST include summary="keyword,keyword" tags.
-Info: Paths are addresses for tools. Summary tags tell you what's inside.
-Info: Path and summary information is approximate. YOU MUST use <get/> to verify before acting on summarized content.
-Info: When information conflicts, later turns are more likely to be relevant and correct than earlier turns.
-Info: Your context is limited but your archive is not. Organize and categorize your facts, decisions, plans, and history to optimize your context.
-
-Required: YOU MUST promote all relevant "summary" entries to "full".
-Required: YOU MUST demote all irrelevant "full" entries to "summary".
-
-Required: YOU MUST conclude every turn with EITHER <update></update> if still working OR <summarize></summarize> if done. Never both.
-Required: YOU MUST use one and only one <update></update> or <summarize></summarize> tag, and only at the end.
-
-# Tool Commands
-
-Tools: [%TOOLS%]
+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,4 +1,6 @@
-import docs from "./knownDoc.js";
+import { countTokens } from "../../agent/tokens.js";
+
+const MAX_ENTRY_TOKENS = Number(process.env.RUMMY_MAX_ENTRY_TOKENS) || 512;
 
 export default class Known {
 	#core;
@@ -7,29 +9,81 @@ 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("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) {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
-		const target = entry.attributes.path || entry.resultPath;
-		await store.upsert(runId, turn, target, entry.body, 200, { loopId });
+		if (!entry.body) return;
+
+		// Size gate
+		const entryTokens = countTokens(entry.body);
+		if (entryTokens > MAX_ENTRY_TOKENS) {
+			const rejectPath = await store.slugPath(runId, "known", entry.body);
+			await store.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;
+		}
+
+		// Resolve path: explicit or auto-generated slug
+		let knownPath = entry.attributes?.path || null;
+		if (knownPath && !knownPath.includes("://")) {
+			knownPath = `known://${knownPath}`;
+		}
+		if (!knownPath) {
+			knownPath = await store.slugPath(
+				runId,
+				"known",
+				entry.body,
+				entry.attributes?.summary,
+			);
+		}
+
+		// Dedup: if path exists, update rather than duplicate
+		const existing = await store.getEntriesByPattern(runId, knownPath, null);
+		if (existing.length > 0) {
+			await store.upsert(
+				runId,
+				turn,
+				existing[0].path,
+				entry.body || existing[0].body,
+				200,
+				{ attributes: entry.attributes, loopId },
+			);
+			return;
+		}
+
+		await store.upsert(runId, turn, knownPath, entry.body, 200, {
+			attributes: entry.attributes,
+			loopId,
+		});
 	}
 
 	full(entry) {
-		return `# known ${entry.path}\n${entry.body}`;
+		return entry.body;
+	}
+
+	summary() {
+		return "";
 	}
 
 	async assembleKnown(content, ctx) {
 		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
+		// Rows arrive pre-sorted by SQL: summary → full, then by recency
 		const demotedSet = new Set(ctx.demoted || []);
 		const lines = entries.map((e) => renderKnownTag(e, demotedSet));
 		return `${content}\n\n<knowns>\n${lines.join("\n")}\n</knowns>`;
@@ -48,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.slice(0, 80)}"`
+			? attrs.summary.replace(/"/g, "'").slice(0, 80)
 			: "";
+	const summary = ` summary="${summaryText}"`;
 
 	if (entry.body) {
-		return `<${tag} path="${entry.path}"${turn}${status}${fidelity}${summary}${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}${fidelity}${summary}${tokens}${flag}/>`;
+	return `<${tag} path="${entry.path}"${turn}${status}${summary}${fidelity}${tokens}${flag}/>`;
 }

package/src/plugins/known/knownDoc.js

@@ -2,32 +2,16 @@
 // 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://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.",
 	],
 	[
-		'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.",
+		'* Recall with <get path="known://people/*">keyword</get>',
+		"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

@@ -2,43 +2,17 @@
 // 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.",
+		"Entry rename. Most common mv use case.",
 	],
+	['Example: <mv path="src/old_name.js">src/new_name.js</mv>', "File rename."],
 	[
-		"* In ask mode, destination MUST be a scheme path (not a file)",
-		"Mode constraint. Prevents file mutations in ask mode via mv.",
+		'Example: <mv path="known://project/*" fidelity="demoted"/>',
+		"Batch fidelity change via pattern. No destination = fidelity in place.",
 	],
 ];
 

package/src/plugins/policy/policy.js

@@ -0,0 +1,47 @@
+import KnownStore from "../../agent/KnownStore.js";
+
+export default class Policy {
+	constructor(core) {
+		core.filter("entry.recording", this.#enforceAskMode.bind(this), 1);
+	}
+
+	async #enforceAskMode(entry, ctx) {
+		if (ctx.mode !== "ask") return entry;
+
+		if (entry.scheme === "sh") {
+			console.warn("[RUMMY] Rejected <sh> in ask mode");
+			return { ...entry, status: 403 };
+		}
+
+		if (entry.scheme === "set" && entry.attributes?.path) {
+			const scheme = KnownStore.scheme(entry.attributes.path);
+			if (scheme === null && entry.body) {
+				console.warn(
+					`[RUMMY] Rejected file edit to ${entry.attributes.path} in ask mode`,
+				);
+				return { ...entry, status: 403 };
+			}
+		}
+
+		if (entry.scheme === "rm") {
+			const pathAttr = entry.attributes?.path || entry.path;
+			const scheme = KnownStore.scheme(pathAttr);
+			if (scheme === null) {
+				console.warn(`[RUMMY] Rejected file rm of ${pathAttr} in ask mode`);
+				return { ...entry, status: 403 };
+			}
+		}
+
+		if (entry.scheme === "mv" || entry.scheme === "cp") {
+			const destScheme = KnownStore.scheme(entry.attributes?.to);
+			if (destScheme === null) {
+				console.warn(
+					`[RUMMY] Rejected ${entry.scheme} to file ${entry.attributes?.to} in ask mode`,
+				);
+				return { ...entry, status: 403 };
+			}
+		}
+
+		return entry;
+	}
+}

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,56 +10,34 @@ export default class Progress {
 	}
 
 	async assembleProgress(content, ctx) {
-		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 hasPerformed = loggingEntries.some(
-			(r) => r.source_turn >= ctx.loopStartTurn,
-		);
-
-		const parts = [];
-
-		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" : ""}`
-			: "";
-		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 (hasPerformed) {
-			parts.push(
-				"The above actions were performed in response to the following prompt:",
+		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(
+				`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.",
+		);
+		const body = lines.join("\n");
 
-		return `${content}<progress turn="${ctx.turn}">${parts.join("\n")}</progress>\n`;
+		return `${content}<progress turn="${ctx.turn}">${body}</progress>\n`;
 	}
 }

package/src/plugins/prompt/prompt.js

@@ -3,7 +3,18 @@ export default class Prompt {
 
 	constructor(core) {
 		this.#core = core;
-		core.hooks.tools.onView("prompt", (entry) => entry.body);
+		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 see the complete prompt]`
+					: text;
+			},
+			"demoted",
+		);
 		core.on("turn.started", this.onTurnStarted.bind(this));
 		core.filter("assembly.user", this.assemblePrompt.bind(this), 300);
 	}
@@ -30,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

@@ -2,28 +2,19 @@
 // Text goes to the model. Rationale stays in source.
 // Changing ANY line requires reading ALL rationales first.
 const LINES = [
-	// --- Syntax: path attr, self-closing
 	['## <rm path="[path]"/> - Remove a file or entry'],
-
-	// --- Examples: file, known (with slug path), preview safety
 	['Example: <rm path="src/config.js"/>', "File removal. Simplest form."],
-	[
-		'Example: <rm path="known://config/deprecated_service"/>',
-		"Shows topic-hierarchy path convention. Paths are category/key, not sentence slugs.",
-	],
 	[
 		'Example: <rm path="known://temp_*" preview/>',
-		"Preview before deleting. Glob pattern. Safety pattern for bulk operations.",
+		"Preview before deleting. Safety pattern for bulk operations.",
 	],
-
-	// --- Constraints
 	[
-		'* Permanent. Prefer <set fidelity="archive"/> to preserve for later retrieval',
-		"Nudges toward archive over rm. Archive keeps the key; rm deletes permanently.",
+		'* 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.",
 	],
 	[
-		"* Paths accept patterns — use `preview` to check matches first",
-		"Reinforces preview safety pattern. Prevents accidental bulk deletion.",
+		"* `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.",
 	],
 ];
 

package/src/plugins/rpc/rpc.js

@@ -111,7 +111,7 @@ export default class Rpc {
 				});
 				return { status: "ok" };
 			},
-			description: "Promote entry to full state.",
+			description: "Promote entry fidelity.",
 			params: {
 				path: "string — file path or glob pattern",
 				run: "string — run alias",
@@ -178,7 +178,7 @@ export default class Rpc {
 					scheme: e.scheme,
 					status: e.status,
 					fidelity: e.fidelity,
-					tokens: e.tokens_full,
+					tokens: e.tokens,
 				}));
 			},
 			description: "Query entries by pattern.",
@@ -233,6 +233,7 @@ export default class Rpc {
 						contextLimit: params.contextLimit,
 						noRepo: params.noRepo,
 						noInteraction: params.noInteraction,
+						noProposals: params.noProposals,
 						noWeb: params.noWeb,
 						fork: params.fork,
 					},
@@ -269,6 +270,7 @@ export default class Rpc {
 						contextLimit: params.contextLimit,
 						noRepo: params.noRepo,
 						noInteraction: params.noInteraction,
+						noProposals: params.noProposals,
 						noWeb: params.noWeb,
 						fork: params.fork,
 					},