@possumtech/rummy 0.5.0 → 2.0.0

package/src/plugins/policy/policy.js

@@ -1,44 +1,59 @@
-import KnownStore from "../../agent/KnownStore.js";
+import Entries from "../../agent/Entries.js";
 
 export default class Policy {
+	#core;
+
 	constructor(core) {
+		this.#core = core;
 		core.filter("entry.recording", this.#enforceAskMode.bind(this), 1);
 	}
 
+	async #reject(ctx, message) {
+		await this.#core.hooks.error.log.emit({
+			store: ctx.store,
+			runId: ctx.runId,
+			turn: ctx.turn,
+			loopId: ctx.loopId,
+			message,
+		});
+	}
+
 	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 };
+			await this.#reject(ctx, "Rejected <sh> in ask mode");
+			return { ...entry, state: "failed", outcome: "permission" };
 		}
 
 		if (entry.scheme === "set" && entry.attributes?.path) {
-			const scheme = KnownStore.scheme(entry.attributes.path);
+			const scheme = Entries.scheme(entry.attributes.path);
 			if (scheme === null && entry.body) {
-				console.warn(
-					`[RUMMY] Rejected file edit to ${entry.attributes.path} in ask mode`,
+				await this.#reject(
+					ctx,
+					`Rejected file edit to ${entry.attributes.path} in ask mode`,
 				);
-				return { ...entry, status: 403 };
+				return { ...entry, state: "failed", outcome: "permission" };
 			}
 		}
 
 		if (entry.scheme === "rm") {
 			const pathAttr = entry.attributes?.path || entry.path;
-			const scheme = KnownStore.scheme(pathAttr);
+			const scheme = Entries.scheme(pathAttr);
 			if (scheme === null) {
-				console.warn(`[RUMMY] Rejected file rm of ${pathAttr} in ask mode`);
-				return { ...entry, status: 403 };
+				await this.#reject(ctx, `Rejected file rm of ${pathAttr} in ask mode`);
+				return { ...entry, state: "failed", outcome: "permission" };
 			}
 		}
 
 		if (entry.scheme === "mv" || entry.scheme === "cp") {
-			const destScheme = KnownStore.scheme(entry.attributes?.to);
+			const destScheme = Entries.scheme(entry.attributes?.to);
 			if (destScheme === null) {
-				console.warn(
-					`[RUMMY] Rejected ${entry.scheme} to file ${entry.attributes?.to} in ask mode`,
+				await this.#reject(
+					ctx,
+					`Rejected ${entry.scheme} to file ${entry.attributes?.to} in ask mode`,
 				);
-				return { ...entry, status: 403 };
+				return { ...entry, state: "failed", outcome: "permission" };
 			}
 		}
 

package/src/plugins/prompt/README.md

@@ -1,4 +1,4 @@
-# prompt
+# prompt {#prompt_plugin}
 
 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.

package/src/plugins/prompt/prompt.js

@@ -3,17 +3,16 @@ export default class Prompt {
 
 	constructor(core) {
 		this.#core = core;
-		core.hooks.tools.onView("prompt", (entry) => entry.body, "promoted");
+		core.hooks.tools.onView("prompt", (entry) => entry.body, "visible");
 		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;
+				const full = entry.body;
+				if (full.length <= limit) return full;
+				return `${full.slice(0, limit)}\n[truncated — promote to see the complete prompt]`;
 			},
-			"demoted",
+			"summarized",
 		);
 		core.on("turn.started", this.onTurnStarted.bind(this));
 		core.filter("assembly.user", this.assemblePrompt.bind(this), 300);
@@ -23,15 +22,23 @@ export default class Prompt {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 
 		if (!isContinuation && prompt) {
-			await store.upsert(runId, turn, `prompt://${turn}`, prompt, 200, {
+			// prompt:// writable_by: ["plugin"] — explicit for clarity.
+			await store.set({
+				runId,
+				turn,
+				path: `prompt://${turn}`,
+				body: prompt,
+				state: "resolved",
 				attributes: { mode },
 				loopId,
+				writer: "plugin",
 			});
 		}
 	}
 
 	async assemblePrompt(content, ctx) {
-		const promptEntry = ctx.rows.findLast(
+		const { rows, contextSize, toolSet } = ctx;
+		const promptEntry = rows.findLast(
 			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
 
@@ -39,16 +46,51 @@ export default class Prompt {
 			typeof promptEntry?.attributes === "string"
 				? JSON.parse(promptEntry.attributes)
 				: promptEntry?.attributes;
-		const mode = attrs?.mode || ctx.type;
-		const body = promptEntry?.body || "";
-		// 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:".
+		const mode = attrs?.mode ? attrs.mode : ctx.type;
+		const body = promptEntry ? promptEntry.body : "";
+		const activeTools = toolSet
+			? new Set(toolSet)
+			: new Set(this.#core.hooks.tools.names);
+		const commands = this.#core.hooks.tools.advertisedNames
+			.filter((n) => activeTools.has(n))
+			.join(",");
 		let warn = "";
 		if (mode === "ask") warn = ' warn="File editing disallowed."';
 
-		return `${content}<prompt mode="${mode}"${warn}>${body}</prompt>`;
+		// Surface the most recent prior-turn budget demotion as a
+		// `reverted="N"` attribute on <prompt>. Historical error
+		// entries sit in <log> but read as ambient noise; this signal
+		// is dynamic and always fresh — the model sees that its
+		// promotions last turn were reverted, in the same spot where
+		// it reads budget numbers.
+		let reverted = "";
+		const priorTurn = ctx.turn - 1;
+		if (priorTurn >= 1) {
+			const priorDemotion = rows.find((r) => {
+				if (!r.path.startsWith(`log://turn_${priorTurn}/error/`)) return false;
+				const attrs =
+					typeof r.attributes === "string"
+						? JSON.parse(r.attributes)
+						: r.attributes;
+				return attrs?.status === 413 && attrs?.demotedCount > 0;
+			});
+			if (priorDemotion) {
+				const attrs =
+					typeof priorDemotion.attributes === "string"
+						? JSON.parse(priorDemotion.attributes)
+						: priorDemotion.attributes;
+				reverted = ` reverted="${attrs.demotedCount}"`;
+			}
+		}
+
+		const path = promptEntry ? ` path="${promptEntry.path}"` : "";
+		const visibility = promptEntry?.visibility
+			? ` visibility="${promptEntry.visibility}"`
+			: "";
+		const tokens =
+			promptEntry?.aTokens != null
+				? ` tokens="${promptEntry.aTokens}"`
+				: "";
+		return `${content}<prompt mode="${mode}"${path} commands="${commands}"${warn}${reverted}${visibility}${tokens}>${body}</prompt>`;
 	}
 }

package/src/plugins/rm/README.md

@@ -1,4 +1,4 @@
-# rm
+# rm {#rm_plugin}
 
 Removes entries by path or glob pattern.
 

package/src/plugins/rm/rm.js

@@ -1,6 +1,8 @@
-import KnownStore from "../../agent/KnownStore.js";
+import Entries from "../../agent/Entries.js";
 import docs from "./rmDoc.js";
 
+const LOG_ACTION_RE = /^log:\/\/turn_\d+\/(\w+)\//;
+
 export default class Rm {
 	#core;
 
@@ -8,25 +10,50 @@ export default class Rm {
 		this.#core = core;
 		core.registerScheme();
 		core.on("handler", this.handler.bind(this));
-		core.on("promoted", this.full.bind(this));
-		core.on("demoted", this.summary.bind(this));
+		core.on("visible", this.full.bind(this));
+		core.on("summarized", this.summary.bind(this));
 		core.filter("instructions.toolDocs", async (docsMap) => {
 			docsMap.rm = docs;
 			return docsMap;
 		});
+		core.on("proposal.accepted", this.#onAccepted.bind(this));
+	}
+
+	async #onAccepted(ctx) {
+		const m = LOG_ACTION_RE.exec(ctx.path);
+		if (m?.[1] !== "rm") return;
+		const target = ctx.attrs?.path;
+		if (!target) return;
+		await ctx.entries.rm({ runId: ctx.runId, path: target });
+		if (ctx.projectRoot) {
+			const { unlink } = await import("node:fs/promises");
+			const { join } = await import("node:path");
+			try {
+				await unlink(join(ctx.projectRoot, target));
+			} catch (err) {
+				// File may already be absent — entry rm'd regardless.
+				if (err.code !== "ENOENT") throw err;
+			}
+		}
 	}
 
 	async handler(entry, rummy) {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 		const target = entry.attributes.path;
 		if (!target) {
-			await store.upsert(runId, turn, entry.resultPath, "", 400, {
+			await store.set({
+				runId,
+				turn,
+				path: entry.resultPath,
+				body: "",
+				state: "failed",
+				outcome: "validation",
 				attributes: { error: "path is required" },
 				loopId,
 			});
 			return;
 		}
-		const normalized = KnownStore.normalizePath(target);
+		const normalized = Entries.normalizePath(target);
 		const matches = await store.getEntriesByPattern(
 			runId,
 			normalized,
@@ -34,7 +61,13 @@ export default class Rm {
 		);
 
 		if (matches.length === 0) {
-			await store.upsert(runId, turn, entry.resultPath, "", 404, {
+			await store.set({
+				runId,
+				turn,
+				path: entry.resultPath,
+				body: "",
+				state: "failed",
+				outcome: "not_found",
 				attributes: { path: target, error: `${target} not found` },
 				loopId,
 			});
@@ -45,24 +78,35 @@ export default class Rm {
 		const schemeMatches = matches.filter((m) => m.scheme !== null);
 
 		// Scheme entries: remove all, write one aggregate result entry
-		for (const match of schemeMatches) await store.remove(runId, match.path);
+		for (const match of schemeMatches)
+			await store.rm({ runId: runId, path: match.path });
 		if (schemeMatches.length > 0) {
 			const paths = schemeMatches.map((m) => m.path).join("\n");
-			await store.upsert(runId, turn, entry.resultPath, paths, 200, {
+			await store.set({
+				runId,
+				turn,
+				path: entry.resultPath,
+				body: paths,
+				state: "resolved",
 				attributes: { path: target },
 				loopId,
 			});
 		}
 
-		// File entries: individual 202 proposals (require user resolution)
+		// File entries: individual proposals (require user resolution)
 		if (fileMatches.length > 0 && schemeMatches.length > 0)
-			await store.remove(runId, entry.resultPath);
+			await store.rm({ runId: runId, path: entry.resultPath });
 		for (const match of fileMatches) {
 			const resultPath =
 				schemeMatches.length === 0 && fileMatches.length === 1
 					? entry.resultPath
-					: await store.dedup(runId, "rm", match.path, turn);
-			await store.upsert(runId, turn, resultPath, match.path, 202, {
+					: await store.logPath(runId, turn, "rm", match.path);
+			await store.set({
+				runId,
+				turn,
+				path: resultPath,
+				body: match.path,
+				state: "proposed",
 				attributes: { path: match.path },
 				loopId,
 			});

package/src/plugins/rm/rmDoc.js

@@ -1,21 +1,3 @@
-// Tool doc for <rm>. Each entry: [text, rationale].
-// Text goes to the model. Rationale stays in source.
-// Changing ANY line requires reading ALL rationales first.
-const LINES = [
-	['## <rm path="[path]"/> - Remove a file or entry'],
-	['Example: <rm path="src/config.js"/>', "File removal. Simplest form."],
-	[
-		'Example: <rm path="known://temp_*" preview/>',
-		"Preview before deleting. Safety pattern for bulk operations.",
-	],
-	[
-		'* 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.",
-	],
-	[
-		"* `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.",
-	],
-];
+import { loadDoc } from "../helpers.js";
 
-export default LINES.map(([text]) => text).join("\n");
+export default loadDoc(import.meta.url, "rmDoc.md");

package/src/plugins/rm/rmDoc.md

@@ -0,0 +1,13 @@
+## <rm path="[path]"/> - Remove a file or entry
+
+Example: <rm path="src/config.js"/>
+<!-- File removal. Simplest form. -->
+
+Example: <rm path="known://temp_*" preview/>
+<!-- Preview before deleting. Safety pattern for bulk operations. -->
+
+* Permanent. Prefer <set path="..." visibility="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. -->
+
+* `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/README.md

@@ -1,4 +1,4 @@
-# rpc
+# rpc {#rpc_plugin}
 
 Registers core RPC methods and provides automatic tool dispatch for
 all registered tools.
@@ -29,4 +29,4 @@ all registered tools.
 - `getRuns`, `getRun`
 
 ### Notifications
-- `run/state`, `run/progress`, `ui/render`, `ui/notify`
+- `run/state`, `run/progress`, `run/proposal`, `ui/render`, `ui/notify`, `stream/cancelled`