@possumtech/rummy 0.4.0 → 0.5.0

package/src/agent/XmlParser.js

@@ -154,6 +154,11 @@ export default class XmlParser {
 		const commands = [];
 		const warnings = [];
 		const textChunks = [];
+
+		// Pre-flight: balance unclosed attribute quotes that would otherwise
+		// cause htmlparser2 to consume the rest of input as a single attribute
+		// value, silently dropping every subsequent tool call.
+		const balanced = XmlParser.#balanceAttrQuotes(normalized, warnings);
 		let current = null;
 		let ended = false;
 		let capped = false;
@@ -162,35 +167,50 @@ export default class XmlParser {
 			{
 				onopentag(name, attrs) {
 					if (capped) return;
-					if (!ALL_TOOLS.has(name)) {
-						if (current) {
+
+					if (current) {
+						// Empty-body case: current tool opened but got no text
+						// content before a new tag. The model likely meant current
+						// to self-close but typed it in paired form, or emitted a
+						// mismatched close tag that htmlparser2 silently dropped.
+						// Close current, open new.
+						const hasBody = current.rawBody.trim() !== "";
+						const hasNestedOpens = (current.nested || []).length > 0;
+						if (!hasBody && !hasNestedOpens && ALL_TOOLS.has(name)) {
+							warnings.push(
+								`Unclosed <${current.name}> before <${name}> — recovered`,
+							);
+							commands.push(
+								resolveCommand(current.name, current.attrs, current.rawBody),
+							);
+							current = null;
+						} else {
+							// Nested tag inside a body with content — treat as body
+							// text. Tool bodies are opaque: the model writing a plan
+							// with <get/> in it, SEARCH/REPLACE in <set>, or XML
+							// examples in <known> all need to survive intact. Track
+							// nested opens on a stack so matching closes pop off and
+							// orphan closes (typos) still trigger recovery.
 							const attrStr = Object.entries(attrs)
-								.map(([k, v]) => v === "" ? k : `${k}="${v}"`)
+								.map(([k, v]) => (v === "" ? k : `${k}="${v}"`))
 								.join(" ");
 							current.rawBody += attrStr
 								? `<${name} ${attrStr}>`
 								: `<${name}>`;
+							current.nested ||= [];
+							current.nested.push(name);
+							return;
 						}
-						return;
 					}
 
-					// Known tool opened while another is still open — close the old one.
-					if (current) {
-						warnings.push(
-							`Unclosed <${current.name}> before <${name}> — recovered`,
-						);
-						commands.push(
-							resolveCommand(current.name, current.attrs, current.rawBody),
-						);
-					}
+					if (!ALL_TOOLS.has(name)) return;
 
 					if (commands.length >= XmlParser.MAX_COMMANDS) {
 						capped = true;
-						current = null;
 						return;
 					}
 
-					current = { name, attrs, rawBody: "" };
+					current = { name, attrs, rawBody: "", nested: [] };
 				},
 
 				ontext(text) {
@@ -204,28 +224,52 @@ export default class XmlParser {
 
 				onclosetag(name, isImplied) {
 					if (capped) return;
-					if (current && name === current.name) {
-						if (ended) {
-							warnings.push(`Unclosed <${name}> tag — content captured anyway`);
+
+					if (current) {
+						// Matching nested close — pop stack, keep as text.
+						const nested = current.nested;
+						if (
+							nested.length > 0 &&
+							nested[nested.length - 1] === name
+						) {
+							nested.pop();
+							current.rawBody += `</${name}>`;
+							return;
 						}
-						commands.push(
-							resolveCommand(current.name, current.attrs, current.rawBody),
-						);
-						current = null;
-					} else if (current && ALL_TOOLS.has(name)) {
-						// Mismatched close tag for a known tool — close current tag,
-						// don't swallow subsequent commands as body text.
-						warnings.push(
-							`Mismatched </${name}> closing <${current.name}> — recovered`,
-						);
-						commands.push(
-							resolveCommand(current.name, current.attrs, current.rawBody),
-						);
-						current = null;
-					} else if (current) {
+
+						// Matching close for outer tool — finalize.
+						if (name === current.name && nested.length === 0) {
+							if (ended) {
+								warnings.push(
+									`Unclosed <${name}> tag — content captured anyway`,
+								);
+							}
+							commands.push(
+								resolveCommand(current.name, current.attrs, current.rawBody),
+							);
+							current = null;
+							return;
+						}
+
+						// Orphan close for a known tool (likely typo) — recover.
+						if (ALL_TOOLS.has(name)) {
+							warnings.push(
+								`Mismatched </${name}> closing <${current.name}> — recovered`,
+							);
+							commands.push(
+								resolveCommand(current.name, current.attrs, current.rawBody),
+							);
+							current = null;
+							return;
+						}
+
+						// Unknown orphan close — text.
 						current.rawBody += `</${name}>`;
-					} else if (isImplied && ALL_TOOLS.has(name)) {
-						// Self-closing tag that htmlparser2 auto-closed
+						return;
+					}
+
+					if (isImplied && ALL_TOOLS.has(name)) {
+						// Self-closing tag that htmlparser2 auto-closed at top level
 					}
 				},
 
@@ -240,7 +284,7 @@ export default class XmlParser {
 			},
 		);
 
-		parser.write(normalized);
+		parser.write(balanced);
 		ended = true;
 		parser.end();
 
@@ -263,6 +307,36 @@ export default class XmlParser {
 		return { commands, warnings, unparsed };
 	}
 
+	/**
+	 * Repair a specific malformed-tag pattern: an attribute value opened with
+	 * `="` that never closes before the next tag. Without repair, htmlparser2
+	 * consumes the rest of input as one giant attribute value and silently
+	 * drops every subsequent tool call.
+	 *
+	 * Pattern matched:  <TAG ... ATTR="text-with-no-quote</NEXT>
+	 * Repair:           <TAG ... ATTR="text-with-no-quote"></NEXT>
+	 *
+	 * Conservative — only triggers when the value contains no quote, no `>`,
+	 * and is followed by another tag opening or close. Well-formed input is
+	 * untouched.
+	 */
+	static #balanceAttrQuotes(content, warnings) {
+		let fixes = 0;
+		const repaired = content.replace(
+			/(<\w+\s[^<>]*?\w+=")([^"<>]*?)(<\/?\w+)/g,
+			(_, opening, value, nextTag) => {
+				fixes++;
+				return `${opening}${value}">${nextTag}`;
+			},
+		);
+		if (fixes > 0) {
+			warnings.push(
+				`Repaired ${fixes} malformed attribute(s) — close all attribute values with a quote.`,
+			);
+		}
+		return repaired;
+	}
+
 	/**
 	 * Normalize native tool call formats to rummy XML.
 	 * Models sometimes emit their training-format tool calls instead of
@@ -276,12 +350,30 @@ export default class XmlParser {
 		);
 
 		// Qwen/gemma: <|tool_call>call:NAME{key:"value"}<tool_call|>
+		// NAME may be namespaced with any of /, :, or . separators
+		// (e.g. `rummy.nvim/get`, `rummy:get`) — extract the trailing word
+		// sequence as the tool name. Value forms observed in the wild:
+		//   key="v" / key:"v" / key:v (unquoted) / key:<|"|>v<|"|> (gemma chat-quotes)
 		result = result.replace(
-			/<\|tool_call>call:(\w+)\{([^}]*)\}<(?:tool_call\||\|tool_call)>/g,
-			(_, name, params) => {
-				if (!ALL_TOOLS.has(name)) return _;
-				const valueMatch = params.match(/["']([^"']+)["']/);
-				const body = valueMatch?.[1] || "";
+			/<\|tool_call>call:([\w.:/-]+)\{([^}]*)\}<(?:tool_call\||\|tool_call)>/g,
+			(match, qualifiedName, params) => {
+				const name = qualifiedName.match(/\w+$/)?.[0] ?? qualifiedName;
+				if (!ALL_TOOLS.has(name)) {
+					return `<error>Unknown tool '${qualifiedName}' in <|tool_call> format. Use XML tool commands listed above.</error>`;
+				}
+				const valueMatch = params.match(
+					/[=:]\s*(?:<\|"\|>([^<]*?)<\|"\|>|"([^"]*)"|'([^']*)'|([^,}]+))/,
+				);
+				const body = (
+					valueMatch?.[1] ??
+					valueMatch?.[2] ??
+					valueMatch?.[3] ??
+					valueMatch?.[4] ??
+					""
+				).trim();
+				if (!body) {
+					return `<error>Could not extract argument from <|tool_call> ${match}. Use XML format like <${name}>value</${name}>.</error>`;
+				}
 				return `<${name}>${body}</${name}>`;
 			},
 		);
@@ -319,6 +411,23 @@ export default class XmlParser {
 			},
 		);
 
+		// Catch-all: any remaining <|tool_call> tokens are malformed native
+		// attempts (no {} block, missing close, wrong shape entirely). Replace
+		// each with an <error> so the model gets feedback on its next turn and
+		// learns to switch to XML. Lazy-match up to the next native close, the
+		// next XML close tag, or end of input — preserves any trailing valid XML.
+		// Error body must NOT contain literal <get>/<set>/etc. — those would
+		// re-enter the parser as phantom tool calls. Describe the format in
+		// prose instead and point at the tool docs above.
+		result = result.replace(
+			/<\|tool_call>[\s\S]*?(?:<\|?tool_call\|?>|<\/\w+>|$)/g,
+			() =>
+				"<error>Native tool call format not supported. Use the XML tool commands listed above (e.g. a get tag with a path attribute, or a set tag with path and body).</error>",
+		);
+
+		// Strip any orphan chat-format quote tokens left after replacement.
+		result = result.replace(/<\|"\|>/g, '"');
+
 		return result;
 	}
 }

package/src/agent/known_store.sql

@@ -59,7 +59,7 @@ WHERE run_id = :run_id AND hedmatch(:pattern, path) AND scheme IS NULL;
 -- PREP: promote_path
 UPDATE known_entries
 SET
-	fidelity = 'full'
+	fidelity = 'promoted'
 	, status = 200
 	, turn = :turn
 	, updated_at = CURRENT_TIMESTAMP
@@ -68,7 +68,7 @@ WHERE run_id = :run_id AND path = :path;
 -- PREP: demote_path
 UPDATE known_entries
 SET
-	fidelity = 'archive'
+	fidelity = 'archived'
 	, updated_at = CURRENT_TIMESTAMP
 WHERE run_id = :run_id AND path = :path;
 
@@ -111,7 +111,7 @@ WHERE run_id = :run_id AND path = :path;
 -- PREP: promote_by_pattern
 UPDATE known_entries
 SET
-	fidelity = 'full'
+	fidelity = 'promoted'
 	, status = 200
 	, turn = :turn
 	, updated_at = CURRENT_TIMESTAMP
@@ -123,7 +123,7 @@ WHERE
 -- PREP: demote_by_pattern
 UPDATE known_entries
 SET
-	fidelity = 'archive'
+	fidelity = 'archived'
 	, updated_at = CURRENT_TIMESTAMP
 WHERE
 	run_id = :run_id
@@ -163,27 +163,34 @@ WHERE
 	AND (:body IS NULL OR hedsearch(:body, body));
 
 -- PREP: restore_summarized_prompts
--- Restore prompt entries demoted to summary by a recovery phase that was
+-- Restore prompt entries demoted by a recovery phase that was
 -- interrupted (e.g. server crash). Safe to call unconditionally at loop
 -- start: if the full prompt would overflow, Prompt Demotion handles it.
 UPDATE known_entries
 SET
-	fidelity = 'full'
+	fidelity = 'promoted'
 	, updated_at = CURRENT_TIMESTAMP
-WHERE run_id = :run_id AND scheme = 'prompt' AND fidelity = 'summary';
+WHERE run_id = :run_id AND scheme = 'prompt' AND fidelity = 'demoted';
 
 -- PREP: demote_turn_entries
--- Demote all full entries from a turn to summary with 413 status.
+-- Demote all promoted entries from a turn for budget claw-back.
+-- Action schemes (set/rm/mv/cp) at status 200 keep their status — those
+-- represent committed side effects (files written/removed) that can't be
+-- clawed back; only the body in context is demoted, not the truth of what
+-- happened. Everything else flips to 413 since promotion was reversed.
 -- Tokens unchanged — always reports full cost regardless of fidelity.
 UPDATE known_entries
 SET
-	fidelity = 'summary'
-	, status = 413
+	fidelity = 'demoted'
+	, status = CASE
+		WHEN scheme IN ('set', 'rm', 'mv', 'cp') AND status = 200 THEN 200
+		ELSE 413
+	END
 	, updated_at = CURRENT_TIMESTAMP
 WHERE
 	run_id = :run_id
 	AND turn = :turn
-	AND fidelity = 'full'
+	AND fidelity = 'promoted'
 	AND status < 400
 RETURNING path, tokens;
 

package/src/hooks/PluginContext.js

@@ -69,10 +69,16 @@ export default class PluginContext {
 		this.#hooks.tools.ensureTool(this.#name);
 	}
 
+	// Mark this plugin's tool as hidden from model-facing tool lists.
+	// Handler still dispatches if the model emits the tag.
+	markHidden() {
+		this.#hooks.tools.markHidden(this.#name);
+	}
+
 	/**
 	 * Register a named callback for this plugin.
 	 * "handler" registers the tool handler.
-	 * "full"/"summary" register fidelity projections.
+	 * "promoted"/"demoted" register fidelity projections.
 	 * "docs" sets tool documentation.
 	 * Everything else resolves to a hook event.
 	 */
@@ -82,7 +88,7 @@ export default class PluginContext {
 			this.#hooks.tools.onHandle(this.#name, callback, priority);
 			return;
 		}
-		if (event === "full" || event === "summary") {
+		if (event === "promoted" || event === "demoted") {
 			this.#hooks.tools.onView(this.#name, callback, event);
 			return;
 		}

package/src/hooks/RummyContext.js

@@ -103,9 +103,12 @@ export default class RummyContext {
 
 	async set({ path, body, status = 200, fidelity, attributes } = {}) {
 		if (!path) {
-			const slugify = (await import("../sql/functions/slugify.js")).default;
-			const base = slugify(body || "");
-			path = `known://${base || Date.now()}`;
+			path = await this.entries.slugPath(
+				this.runId,
+				"known",
+				body || "",
+				attributes?.summary,
+			);
 		}
 		await this.entries.upsert(
 			this.runId,

package/src/hooks/ToolRegistry.js

@@ -32,12 +32,21 @@ export default class ToolRegistry {
 	#tools = new Map();
 	#handlers = new Map();
 	#views = new Map();
+	#hidden = new Set();
 
 	ensureTool(scheme) {
 		if (this.#tools.has(scheme)) return;
 		this.#tools.set(scheme, Object.freeze({}));
 	}
 
+	// Mark a tool as hidden — handler still dispatches if the model emits the
+	// tag, but the tool is excluded from all model-facing tool lists. Used for
+	// legacy/internal schemes (e.g. <known>, <unknown>) we want to retire
+	// without deleting.
+	markHidden(scheme) {
+		this.#hidden.add(scheme);
+	}
+
 	get(name) {
 		return this.#tools.get(name);
 	}
@@ -53,7 +62,7 @@ export default class ToolRegistry {
 		list.sort((a, b) => a.priority - b.priority);
 	}
 
-	onView(scheme, fn, fidelity = "full") {
+	onView(scheme, fn, fidelity = "promoted") {
 		if (!this.#views.has(scheme)) this.#views.set(scheme, new Map());
 		this.#views.get(scheme).set(fidelity, fn);
 	}
@@ -67,32 +76,11 @@ export default class ToolRegistry {
 			);
 		}
 
-		const attrs =
-			typeof entry.attributes === "string"
-				? JSON.parse(entry.attributes)
-				: entry.attributes;
-		const summary = typeof attrs?.summary === "string" ? attrs.summary : null;
-
-		const fidelity = entry.fidelity || "full";
+		const fidelity = entry.fidelity || "promoted";
 		const fn = fidelityMap.get(fidelity);
-		if (!fn) {
-			// No view for this fidelity — fall back on model-authored summary
-			return summary || "";
-		}
-
-		const body = await fn(entry);
-
-		// Prepend summary keywords above plugin output at summary fidelity
-		if (fidelity === "summary" && summary && body) {
-			return `${summary}\n${body}`;
-		}
-
-		// Fall back to summary attribute when plugin returns empty
-		if (fidelity === "summary" && summary && !body) {
-			return summary;
-		}
+		if (!fn) return "";
 
-		return body;
+		return fn(entry);
 	}
 
 	hasView(scheme) {
@@ -113,15 +101,23 @@ export default class ToolRegistry {
 		return sortByPriority([...this.#tools.keys()]);
 	}
 
+	// Names advertised to the model — registered tools minus hidden ones.
+	// Use this anywhere a tool list is shown to the model.
+	get advertisedNames() {
+		return sortByPriority(
+			[...this.#tools.keys()].filter((n) => !this.#hidden.has(n)),
+		);
+	}
+
 	/**
 	 * Compute the active tool set for a loop.
-	 * All exclusions — mode, flags — handled here. One mechanism.
+	 * All exclusions — mode, flags, hidden — handled here. One mechanism.
 	 */
 	resolveForLoop(
 		mode,
 		{ noInteraction = false, noWeb = false, noProposals = false } = {},
 	) {
-		const excluded = new Set();
+		const excluded = new Set(this.#hidden);
 		if (mode === "ask") excluded.add("sh");
 		if (noInteraction) excluded.add("ask_user");
 		if (noWeb) excluded.add("search");

package/src/plugins/ask_user/ask_user.js

@@ -7,8 +7,8 @@ export default class AskUser {
 		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.ask_user = docs;
 			return docsMap;

package/src/plugins/ask_user/ask_userDoc.js

@@ -2,13 +2,15 @@
 // Text goes to the model. Rationale stays in source.
 // Changing ANY line requires reading ALL rationales first.
 const LINES = [
-	['## <ask_user question="[Question?]">[option1; option2; ...]</ask_user>'],
+	[
+		'## <ask_user question="[Question?]">[option1; option2; ...]</ask_user> - Ask the user a question',
+	],
 	[
 		"* YOU SHOULD use for decisions, preferences, or approvals the user must make",
 		"Positive framing. Shows what ask_user IS for.",
 	],
 	[
-		"* YOU SHOULD use <get> to find information before asking the user",
+		"* YOU SHOULD use <get></get> to find information before asking the user",
 		"Gentle redirect. Encourages self-sufficiency.",
 	],
 	[

package/src/plugins/budget/README.md

@@ -15,9 +15,11 @@ tools run uninterrupted. Enforcement happens at boundaries.
    the incoming prompt). Model runs in the headroom.
 
 2. **Post-dispatch Turn Demotion**: after all tools dispatch, check
-   context. If over ceiling → demote ALL entries from this turn to
-   summary (every scheme except `budget`). Write `budget://` entry
-   listing what was demoted. Model sees it next turn and adapts.
+   context. If over ceiling → demote ALL entries from this turn
+   (every scheme except `budget`/`system`/`prompt`/`instructions`,
+   and 4xx error states stay promoted). Write `budget://` entry with
+   directive to demote irrelevant entries and promote fewer next time.
+   Model sees it next turn and adapts.
 
 3. **LLM rejection** (`isContextExceeded`): turn-1 token estimate
    drift causes LLM to reject. Same demotion pattern.
@@ -36,4 +38,4 @@ tools run uninterrupted. Enforcement happens at boundaries.
 
 - **Hook**: `hooks.budget.enforce` — pre-LLM ceiling check.
 - **Scheme**: `budget://` — logging category, model-visible. `onView`
-  renders body at all fidelity levels (summary shows full content).
+  renders body at all fidelity levels (demoted shows full content).

package/src/plugins/budget/budget.js

@@ -82,22 +82,42 @@ export default class Budget {
 			turn,
 		});
 
-		// Also summarize the prompt
+		// Also demote the prompt
 		const promptRow = rows.find((r) => r.scheme === "prompt");
 		if (promptRow) {
-			await store.setFidelity(runId, promptRow.path, "summary");
+			await store.setFidelity(runId, promptRow.path, "demoted");
 		}
 
-		// Write budget entry
+		// Rewrite get-result bodies — the get handler claimed "promoted" success
+		// before this panic ran. Without rewriting, the model reads conflicting
+		// signals next turn (status=413 but body says "promoted").
+		for (const entry of demotedEntries) {
+			if (!entry.path.startsWith("get://")) continue;
+			await db.resolve_known_entry.run({
+				run_id: runId,
+				path: entry.path,
+				body: `Demoted by budget. See budget://${loopId}/${turn}.`,
+				status: 413,
+			});
+		}
+
+		// Write budget entry — terse, actionable. Path list dropped since
+		// demoted entries already render at fidelity="demoted" in <knowns>/<files>.
+		// "tokens remaining" dropped too — the number was over-optimistic (it
+		// treated re-demoted files as freeing their full-body tokens when their
+		// demoted-view renderings return to baseline). Model reads the truthful
+		// remaining in next turn's progress line.
+		//
+		// The 50% rule is the key directive: it forces the model to sum
+		// promotion costs (which is the behavior we want), and the threshold
+		// gives a concrete ceiling for the next try. Twofer — abiding by the
+		// rule requires budget awareness as a side effect.
 		const ceiling = Math.floor(contextSize * CEILING_RATIO);
 		const totalDemoted = demotedEntries.reduce((s, r) => s + r.tokens, 0);
-		const pathList = demotedEntries
-			.map((r) => `${r.path} (${r.tokens} tokens)`)
-			.join("\n");
 		const body = [
-			`Error 413: Context overflowed by ${postBudget.overflow} tokens.`,
-			`${demotedEntries.length} entries (${totalDemoted} tokens total) demoted. Budget: ${ceiling} tokens.`,
-			pathList,
+			`413 Token Budget Error: overflowed by ${postBudget.overflow} tokens. Token Budget: ${ceiling}.`,
+			`Your ${demotedEntries.length} promotions from last turn (${totalDemoted} tokens total) were demoted to fit.`,
+			`Required: sum the tokens="N" of your promotions and new entries before emitting. A single turn must add no more than 50% of remaining Token Budget.`,
 		].join("\n");
 
 		await store.upsert(runId, turn, `budget://${loopId}/${turn}`, body, 413, {

package/src/plugins/cp/cp.js

@@ -8,8 +8,8 @@ export default class Cp {
 		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.cp = docs;
 			return docsMap;
@@ -19,7 +19,7 @@ export default class Cp {
 	async handler(entry, rummy) {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 		const { path, to } = entry.attributes;
-		const VALID = { stored: 1, summary: 1, index: 1, full: 1, archive: 1 };
+		const VALID = { promoted: 1, demoted: 1, archived: 1 };
 		const fidelity = VALID[entry.attributes.fidelity]
 			? entry.attributes.fidelity
 			: undefined;
@@ -53,7 +53,7 @@ export default class Cp {
 		return `# cp ${entry.attributes.from || ""} ${entry.attributes.to || ""}`;
 	}
 
-	summary(entry) {
-		return this.full(entry);
+	summary() {
+		return "";
 	}
 }

package/src/plugins/cp/cpDoc.js

@@ -11,14 +11,6 @@ const LINES = [
 		'Example: <cp path="known://plan_*">known://archive_</cp>',
 		"Glob batch copy across known entries.",
 	],
-	[
-		"* Source path accepts patterns: `src/*.js`, `known://draft_*`",
-		"Pattern support consistent with get/rm.",
-	],
-	[
-		"* Use `preview` to check matches before pattern-based bulk copy",
-		"Safety pattern consistent with rm.",
-	],
 ];
 
 export default LINES.map(([text]) => text).join("\n");

package/src/plugins/engine/engine.sql

@@ -6,7 +6,7 @@ FROM known_entries AS ke
 JOIN schemes AS s ON s.name = COALESCE(ke.scheme, 'file')
 WHERE
 	ke.run_id = :run_id
-	AND ke.fidelity IN ('full', 'summary')
+	AND ke.fidelity IN ('promoted', 'demoted')
 	AND s.model_visible = 1
 ORDER BY ke.turn, ke.refs, ke.tokens DESC;
 

package/src/plugins/env/env.js

@@ -7,8 +7,8 @@ export default class Env {
 		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.env = docs;
 			return docsMap;
@@ -27,7 +27,7 @@ export default class Env {
 		return `# env ${entry.attributes.command || ""}\n${entry.body}`;
 	}
 
-	summary(entry) {
-		return entry.attributes.command || "";
+	summary() {
+		return "";
 	}
 }

package/src/plugins/env/envDoc.js

@@ -12,11 +12,11 @@ const LINES = [
 		"Git history. Shows env for read-only investigation.",
 	],
 	[
-		'* YOU MUST NOT use <env/> to read or list files — use <get path="*" preview/> instead',
+		'* YOU MUST NOT use <env></env> to read or list files — use <get path="*"/> instead',
 		"Prevents cat/ls through shell. Forces file access through get.",
 	],
 	[
-		"* YOU MUST NOT use <env/> for commands with side effects",
+		"* YOU MUST NOT use <env></env> for commands with side effects",
 		"Separates exploration from action. env = observe only.",
 	],
 ];