@possumtech/rummy 2.0.1 → 2.1.0

package/src/plugins/known/known.js

@@ -12,10 +12,9 @@ export default class Known {
 		core.on("handler", this.handler.bind(this));
 		core.on("visible", this.full.bind(this));
 		core.on("summarized", this.summary.bind(this));
-		core.filter("assembly.system", this.assembleContext.bind(this), 100);
-		// <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.filter("assembly.user", this.assembleSummarized.bind(this), 50);
+		core.filter("assembly.user", this.assembleVisible.bind(this), 75);
+		// Hidden tool: written via <set path="known://...">; handler tolerates direct <known>.
 		core.markHidden();
 	}
 
@@ -23,23 +22,20 @@ export default class Known {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 		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.set({
 				runId,
 				turn,
-				path: rejectPath,
+				loopId,
+				path: entry.resultPath,
 				body: `Entry too large (${entryTokens} tokens, max ${MAX_ENTRY_TOKENS}). Sort the information, ideas, or plans carefully into multiple entries.`,
 				state: "failed",
 				outcome: `overflow:${entryTokens}`,
-				loopId,
 			});
 			return;
 		}
 
-		// Resolve path: explicit or auto-generated slug
 		let knownPath = entry.attributes?.path;
 		if (knownPath && !knownPath.includes("://")) {
 			knownPath = `known://${knownPath}`;
@@ -53,9 +49,7 @@ export default class Known {
 			);
 		}
 
-		// Dedup: if path exists, update rather than duplicate. An empty
-		// new body means "preserve the existing entry's body" (e.g. the
-		// model is updating attributes only).
+		// Dedup: existing path → update; empty body preserves existing body.
 		const existing = await store.getEntriesByPattern(runId, knownPath, null);
 		if (existing.length > 0) {
 			const nextBody = entry.body === "" ? existing[0].body : entry.body;
@@ -86,28 +80,41 @@ export default class Known {
 		return entry.body;
 	}
 
-	// Summarized knowns keep the first 500 characters so the model
-	// doesn't lose the plot when budget auto-demotion kicks in on its
-	// own work. Anything larger gets capped so a pathologically big
-	// known doesn't saturate the packet at summarized visibility
-	// either. Matches the pattern on `<prompt>` summarized view.
+	// Summarized: first 500 chars; matches <prompt> summarized.
 	summary(entry) {
 		if (!entry.body) return "";
 		if (entry.body.length <= 500) return entry.body;
 		return `${entry.body.slice(0, 500)}\n[truncated — promote to see the full body]`;
 	}
 
-	async assembleContext(content, ctx) {
-		const entries = ctx.rows.filter((r) => r.category === "data");
+	// Identity-keyed summary lines: every data entry the run is tracking
+	// at visibility=visible or visibility=summarized.
+	async assembleSummarized(content, ctx) {
+		const entries = ctx.rows.filter(
+			(r) =>
+				r.category === "data" &&
+				(r.visibility === "visible" || r.visibility === "summarized"),
+		);
+		if (entries.length === 0) return content;
+		const lines = entries.map((e) =>
+			renderContextTag(e, e.sBody != null ? e.sBody : e.body),
+		);
+		return `${content}<summarized>\n${lines.join("\n")}\n</summarized>\n`;
+	}
+
+	async assembleVisible(content, ctx) {
+		const entries = ctx.rows.filter(
+			(r) => r.category === "data" && r.visibility === "visible",
+		);
 		if (entries.length === 0) return content;
-		const demotedSet = new Set(ctx.demoted);
-		const lines = entries.map((e) => renderContextTag(e, demotedSet));
-		return `${content}\n\n<context>\n${lines.join("\n")}\n</context>`;
+		const lines = entries.map((e) =>
+			renderContextTag(e, e.vBody != null ? e.vBody : e.body),
+		);
+		return `${content}<visible>\n${lines.join("\n")}\n</visible>\n`;
 	}
 }
 
-function renderContextTag(entry, demotedSet) {
-	// schemeOf() returns NULL / "" for bare file paths; translate for the tag.
+function renderContextTag(entry, projectedBody) {
 	const tag = entry.scheme ? entry.scheme : "file";
 	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
 	const tokens = entry.aTokens != null ? ` tokens="${entry.aTokens}"` : "";
@@ -129,21 +136,16 @@ function renderContextTag(entry, demotedSet) {
 	const stateAttr =
 		entry.state && entry.state !== "resolved" ? ` state="${entry.state}"` : "";
 	const outcomeAttr = entry.outcome ? ` outcome="${entry.outcome}"` : "";
-	const visibility = entry.visibility
-		? ` visibility="${entry.visibility}"`
-		: "";
-	const flag = demotedSet?.has(entry.path) ? " demoted" : "";
-	// Always render summary attribute on knowns — empty value hints the model
-	// it forgot to add searchable keywords.
+	const visibility =
+		entry.visibility === "archived" ? ` visibility="archived"` : "";
 	const summaryText =
 		typeof attrs?.summary === "string"
 			? attrs.summary.replace(/"/g, "'").slice(0, 80)
 			: "";
 	const summary = ` summary="${summaryText}"`;
-
-	const attrStr = `${turn}${status}${stateAttr}${outcomeAttr}${summary}${visibility}${tokens}${lines}${flag}`;
-	if (entry.body) {
-		return `<${tag} path="${entry.path}"${attrStr}>${entry.body}</${tag}>`;
+	const attrStr = `${turn}${status}${stateAttr}${outcomeAttr}${summary}${visibility}${tokens}${lines}`;
+	if (projectedBody) {
+		return `<${tag} path="${entry.path}"${attrStr}>${projectedBody}</${tag}>`;
 	}
 	return `<${tag} path="${entry.path}"${attrStr}/>`;
 }

package/src/plugins/log/README.md

@@ -29,7 +29,7 @@ size. Resolution:
   own body tokens.
 - `sh` and `env` own multiple streaming channels (`sh://turn_N/{slug}_N`)
   — no single target to point at. `tokens=` is omitted; the channels
-  render their own tokens in `<context>`.
+  render their own tokens in `<visible>`.
 
 ## Behavior
 
@@ -43,6 +43,6 @@ Log entries (`log://turn_N/{action}/{slug}`) are audit records —
 summary, exit status, references to where the data lives — and never
 carry the payload itself. Payload for streaming actions lives under the
 producer's own scheme (`sh://`, `env://`, future `search://`, etc.) at
-`category=data`, and is rendered inside `<context>` by the known
+`category=data`, and is rendered inside `<visible>` by the known
 plugin. Scheme determines category; data and logging never share a
 scheme. See [scheme_category_split](#scheme_category_split).

package/src/plugins/log/log.js

@@ -1,11 +1,6 @@
 import { stateToStatus } from "../../agent/httpStatus.js";
 
-// Schemes whose log body is an action summary, not the cost-bearing
-// content. For these, the action's cost lives on a separate data entry
-// (sh/env: streaming channels; set/mv/cp: the target entry). Report
-// tokens from the target when we can resolve it (set/mv/cp via
-// attrs.path); omit entirely for sh/env (multiple channels, no single
-// target to point at).
+// sh/env span multiple channels; channels render their own tokens in <visible>.
 const STREAM_NO_TOKENS = new Set(["sh", "env"]);
 
 export default class Log {
@@ -17,10 +12,7 @@ export default class Log {
 	}
 
 	async assembleLog(content, ctx) {
-		// Log includes action entries (scheme=log) AND prior prompts. The
-		// most recent prompt is rendered separately by the prompt plugin
-		// as `<prompt>`; everything older lives in the log so the model
-		// can see the full question history across a sustained run.
+		// Includes prior prompts; the latest prompt is rendered separately as <prompt>.
 		const latestPrompt = ctx.rows.findLast(
 			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
@@ -39,10 +31,7 @@ export default class Log {
 	}
 }
 
-// Log paths are log://turn_N/action/slug. The second segment is the
-// action — the plugin/tool that produced this log entry (set, get,
-// search, update, error, etc.). Used as the XML tag name. Prompt
-// entries live at prompt://N; they render as <prompt> in history.
+// Action segment of log://turn_N/action/slug → XML tag.
 function actionFromPath(path) {
 	if (path?.startsWith("prompt://")) return "prompt";
 	const match = path?.match(/^log:\/\/turn_\d+\/([^/]+)\//);
@@ -63,23 +52,13 @@ function renderLogTag(entry, rowsByPath) {
 			: entry.state
 				? stateToStatus(entry.state, entry.outcome)
 				: null;
-	// Prompts are uniformly status=200 — uniform value carries no signal
-	// and read as "settled, no action needed." Suppress so cultivation
-	// vocabulary (vary, demote, archive) applies to prompts the same
-	// way it applies to other log entries.
+	// Suppress status on prompts; uniform 200 carries no signal.
 	const status =
 		statusValue != null && action !== "prompt"
 			? ` status="${statusValue}"`
 			: "";
 	const outcomeAttr = entry.outcome ? ` outcome="${entry.outcome}"` : "";
-	// `tokens=` is the promotion premium (aTokens) of the thing this tag
-	// represents — what the model would free by demoting it. For actions
-	// that reference a separate data entry (get/set/mv/cp), resolve via
-	// attrs.path and report the target's aTokens. For actions whose log
-	// body IS the cost-bearing content (search/update/error/ask_user,
-	// plus <get> slice reads), use the log entry's own aTokens. sh/env
-	// span multiple channel entries and are omitted — the channels
-	// render their own tokens in <context>.
+	// tokens = aTokens of the thing this tag represents (target via attrs.path, else self).
 	const isSlice = attrs?.lineStart != null;
 	const targetEntry = attrs?.path ? rowsByPath.get(attrs.path) : null;
 	let tokenSource = null;
@@ -106,14 +85,8 @@ function renderLogTag(entry, rowsByPath) {
 		typeof attrs?.query === "string" ? ` query="${attrs.query}"` : "";
 	const command =
 		typeof attrs?.command === "string" ? ` command="${attrs.command}"` : "";
-	// target= is the path the action touched (e.g. the file/known that was
-	// set, the URL that was fetched). Plugins store it in attrs.path when
-	// they write the log entry.
 	const target = attrs?.path ? ` target="${attrs.path}"` : "";
-	// Slice reads tag the log entry with lineStart/lineEnd/totalLines so
-	// the <get> tag surfaces `lines="a-b/total"` — a concrete handle for
-	// the model to re-issue or compare against another slice. Non-slice
-	// entries surface the simple `lines="N"` from the projected body.
+	// Slice reads emit lines="a-b/total"; others emit simple lines="N".
 	const lines = isSlice
 		? ` lines="${attrs.lineStart}-${attrs.lineEnd}/${attrs.totalLines}"`
 		: lineSource != null

package/src/plugins/ollama/ollama.js

@@ -1,17 +1,13 @@
+import config from "../../agent/config.js";
 import msg from "../../agent/messages.js";
+import { chatCompletionStream } from "../../llm/openaiStream.js";
+import { retryWithBackoff } from "../../llm/retry.js";
 
-const FETCH_TIMEOUT = Number(process.env.RUMMY_FETCH_TIMEOUT);
-if (!FETCH_TIMEOUT) throw new Error("RUMMY_FETCH_TIMEOUT must be set");
+const { FETCH_TIMEOUT } = config;
 
 const PROVIDER = "ollama";
 
-/**
- * Ollama LLM provider plugin. Registers with hooks.llm.providers if
- * OLLAMA_BASE_URL is set; inert otherwise. Handles model aliases of the
- * form `ollama/{modelName}` — e.g. `ollama/llama3.1:8b` or
- * `ollama/library/qwen:7b` (Ollama accepts both bare and
- * registry-qualified model names).
- */
+// Inert unless OLLAMA_BASE_URL is set; ollama/{model[/registry]} aliases.
 export default class Ollama {
 	#baseUrl;
 
@@ -41,70 +37,58 @@ export default class Ollama {
 			? AbortSignal.any([options.signal, timeoutSignal])
 			: timeoutSignal;
 
-		const response = await fetch(`${this.#baseUrl}/v1/chat/completions`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(body),
-			signal,
-		});
-
-		if (!response.ok) {
-			const error = await response.text();
-			throw new Error(
-				msg("error.ollama_api", { status: `${response.status} - ${error}` }),
-			);
-		}
-
-		const data = await response.json();
-
-		for (const choice of data.choices) {
-			const m = choice.message;
-			if (!m) continue;
-			const parts = [m.reasoning_content, m.reasoning, m.thinking].filter(
-				Boolean,
-			);
-			m.reasoning_content =
-				parts.length > 0 ? [...new Set(parts)].join("\n") : null;
+		try {
+			return await chatCompletionStream({
+				url: `${this.#baseUrl}/v1/chat/completions`,
+				headers: {},
+				body,
+				signal,
+			});
+		} catch (err) {
+			if (err.status) {
+				throw new Error(
+					msg("error.ollama_api", { status: `${err.status} - ${err.body}` }),
+				);
+			}
+			throw err;
 		}
-
-		return data;
 	}
 
 	async #getContextSize(model) {
-		for (let attempt = 0; attempt < 3; attempt++) {
-			try {
-				const response = await fetch(`${this.#baseUrl}/api/show`, {
-					method: "POST",
-					headers: { "Content-Type": "application/json" },
-					body: JSON.stringify({ model }),
-					signal: AbortSignal.timeout(FETCH_TIMEOUT),
-				});
-				if (!response.ok) {
-					throw new Error(
-						msg("error.ollama_show_failed", {
-							status: response.status,
-							baseUrl: this.#baseUrl,
-						}),
-					);
-				}
-				const data = await response.json();
-				if (data.model_info) {
-					for (const [key, value] of Object.entries(data.model_info)) {
-						if (key.endsWith(".context_length")) return value;
-					}
-				}
-				throw new Error(msg("error.ollama_no_context_length", { model }));
-			} catch (err) {
-				if (err.message.includes("Ollama")) throw err;
-				if (attempt < 2) {
-					await new Promise((r) => setTimeout(r, (attempt + 1) * 2000));
-					continue;
-				}
+		const fetchContext = async () => {
+			const response = await fetch(`${this.#baseUrl}/api/show`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ model }),
+				signal: AbortSignal.timeout(FETCH_TIMEOUT),
+			});
+			if (!response.ok) {
 				throw new Error(
-					msg("error.ollama_unreachable", { baseUrl: this.#baseUrl }),
-					{ cause: err },
+					msg("error.ollama_show_failed", {
+						status: response.status,
+						baseUrl: this.#baseUrl,
+					}),
 				);
 			}
+			const data = await response.json();
+			if (data.model_info) {
+				for (const [key, value] of Object.entries(data.model_info)) {
+					if (key.endsWith(".context_length")) return value;
+				}
+			}
+			throw new Error(msg("error.ollama_no_context_length", { model }));
+		};
+		try {
+			return await retryWithBackoff(fetchContext, {
+				deadlineMs: FETCH_TIMEOUT,
+				isRetryable: (err) => !err.message.includes("Ollama"),
+			});
+		} catch (err) {
+			if (err.message.includes("Ollama")) throw err;
+			throw new Error(
+				msg("error.ollama_unreachable", { baseUrl: this.#baseUrl }),
+				{ cause: err },
+			);
 		}
 	}
 }

package/src/plugins/openai/openai.js

@@ -1,16 +1,12 @@
+import config from "../../agent/config.js";
 import msg from "../../agent/messages.js";
+import { chatCompletionStream } from "../../llm/openaiStream.js";
 
-const FETCH_TIMEOUT = Number(process.env.RUMMY_FETCH_TIMEOUT);
-if (!FETCH_TIMEOUT) throw new Error("RUMMY_FETCH_TIMEOUT must be set");
+const { FETCH_TIMEOUT } = config;
 
 const PROVIDER = "openai";
 
-/**
- * OpenAI-compatible LLM provider plugin. Registers with hooks.llm.providers
- * if OPENAI_BASE_URL is set in env; silently inert otherwise. Handles
- * model aliases of the form `openai/{modelName}` — the first path
- * segment picks the provider, the rest is whatever the API expects.
- */
+// Inert unless OPENAI_BASE_URL is set; openai/{model} aliases.
 export default class OpenAi {
 	#baseUrl;
 	#apiKey;
@@ -42,47 +38,36 @@ export default class OpenAi {
 			? AbortSignal.any([options.signal, timeoutSignal])
 			: timeoutSignal;
 
-		const headers = { "Content-Type": "application/json" };
+		const headers = {};
 		if (this.#apiKey) headers.Authorization = `Bearer ${this.#apiKey}`;
 
-		const response = await fetch(`${this.#baseUrl}/v1/chat/completions`, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(body),
-			signal,
-		});
-
-		if (!response.ok) {
-			const error = await response.text();
-			throw new Error(
-				msg("error.openai_api", { status: `${response.status} - ${error}` }),
-			);
-		}
-
-		const data = await response.json();
-
-		for (const choice of data.choices) {
-			const m = choice.message;
-			if (!m) continue;
-			const parts = [m.reasoning_content, m.reasoning, m.thinking].filter(
-				Boolean,
-			);
-			m.reasoning_content =
-				parts.length > 0 ? [...new Set(parts)].join("\n") : null;
-
-			// Full reasoning dump is centralized in telemetry.js on every
-			// provider — keeping it out of provider plugins avoids double
-			// printing and per-provider drift.
+		try {
+			return await chatCompletionStream({
+				url: `${this.#baseUrl}/v1/chat/completions`,
+				headers,
+				body,
+				signal,
+			});
+		} catch (err) {
+			if (err.status) {
+				const wrapped = new Error(
+					msg("error.openai_api", { status: `${err.status} - ${err.body}` }),
+					{ cause: err },
+				);
+				wrapped.status = err.status;
+				wrapped.body = err.body;
+				wrapped.retryAfter = err.retryAfter;
+				throw wrapped;
+			}
+			throw err;
 		}
-
-		return data;
 	}
 
 	async #getContextSize(_model) {
 		const headers = { "Content-Type": "application/json" };
 		if (this.#apiKey) headers.Authorization = `Bearer ${this.#apiKey}`;
 
-		// Try /props first — llama.cpp exposes runtime n_ctx here.
+		// llama.cpp /props returns runtime n_ctx; absent on vanilla OpenAI.
 		try {
 			const propsResponse = await fetch(`${this.#baseUrl}/props`, {
 				headers,
@@ -93,10 +78,7 @@ export default class OpenAi {
 				const runtimeCtx = props?.default_generation_settings?.n_ctx;
 				if (runtimeCtx) return runtimeCtx;
 			}
-		} catch (_err) {
-			// /props is a llama.cpp extension; absent on vanilla OpenAI.
-			// Fall through to /v1/models for the training-context-size hint.
-		}
+		} catch (_err) {}
 
 		// Fall back to /v1/models for training context.
 		const response = await fetch(`${this.#baseUrl}/v1/models`, {

package/src/plugins/openrouter/openrouter.js

@@ -1,20 +1,12 @@
+import config from "../../agent/config.js";
 import msg from "../../agent/messages.js";
+import { chatCompletionStream } from "../../llm/openaiStream.js";
 
-const FETCH_TIMEOUT = Number(process.env.RUMMY_FETCH_TIMEOUT);
-if (!FETCH_TIMEOUT) throw new Error("RUMMY_FETCH_TIMEOUT must be set");
+const { FETCH_TIMEOUT } = config;
 
 const PROVIDER = "openrouter";
 
-/**
- * OpenRouter LLM provider plugin. Handles model aliases of the form
- * `openrouter/{publisher}/{modelName}`. Strips only the provider
- * segment — OpenRouter's own API expects the `publisher/model` form,
- * so that's exactly what's passed through to it (e.g.
- * `openrouter/anthropic/claude-3-opus` → API receives
- * `anthropic/claude-3-opus`).
- *
- * Inert if OPENROUTER_API_KEY / OPENROUTER_BASE_URL aren't set.
- */
+// Inert unless OPENROUTER_API_KEY+OPENROUTER_BASE_URL set; openrouter/{publisher}/{model} aliases.
 export default class OpenRouter {
 	#apiKey;
 	#baseUrl;
@@ -48,52 +40,36 @@ export default class OpenRouter {
 			? AbortSignal.any([options.signal, timeoutSignal])
 			: timeoutSignal;
 
-		const response = await fetch(`${this.#baseUrl}/chat/completions`, {
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${this.#apiKey}`,
-				"Content-Type": "application/json",
-				"HTTP-Referer": process.env.RUMMY_HTTP_REFERER,
-				"X-Title": process.env.RUMMY_X_TITLE,
-			},
-			body: JSON.stringify(body),
-			signal,
-		});
+		const headers = {
+			Authorization: `Bearer ${this.#apiKey}`,
+			"HTTP-Referer": process.env.RUMMY_HTTP_REFERER,
+			"X-Title": process.env.RUMMY_X_TITLE,
+		};
 
-		if (!response.ok) {
-			const error = await response.text();
-			if (response.status === 401 || response.status === 403) {
+		try {
+			return await chatCompletionStream({
+				url: `${this.#baseUrl}/chat/completions`,
+				headers,
+				body,
+				signal,
+			});
+		} catch (err) {
+			if (err.status === 401 || err.status === 403) {
 				throw new Error(
 					msg("error.openrouter_auth", {
-						status: `${response.status} - ${error}`,
+						status: `${err.status} - ${err.body}`,
 					}),
 				);
 			}
-			throw new Error(
-				msg("error.openrouter_api", {
-					status: `${response.status} - ${error}`,
-				}),
-			);
-		}
-		const data = await response.json();
-
-		for (const choice of data.choices) {
-			const cm = choice.message;
-			if (!cm) continue;
-			const details = cm.reasoning_details
-				? cm.reasoning_details.map((d) => d.text)
-				: [];
-			const parts = [
-				cm.reasoning_content,
-				cm.reasoning,
-				cm.thinking,
-				...details,
-			].filter(Boolean);
-			cm.reasoning_content =
-				parts.length > 0 ? [...new Set(parts)].join("\n") : null;
+			if (err.status) {
+				throw new Error(
+					msg("error.openrouter_api", {
+						status: `${err.status} - ${err.body}`,
+					}),
+				);
+			}
+			throw err;
 		}
-
-		return data;
 	}
 
 	async #getContextSize(model) {
@@ -101,7 +77,7 @@ export default class OpenRouter {
 
 		const res = await fetch(`${this.#baseUrl}/models`, {
 			headers: { Authorization: `Bearer ${this.#apiKey}` },
-			signal: AbortSignal.timeout(5000),
+			signal: AbortSignal.timeout(FETCH_TIMEOUT),
 		});
 		if (!res.ok) {
 			throw new Error(

package/src/plugins/policy/README.md

@@ -6,8 +6,14 @@ was started in `ask` mode.
 
 ## Registration
 
-- **Filter**: `entry.recording` (priority 1) — runs before a command
-  becomes an entry.
+- **Filter**: `entry.recording` (priority 1) — the validation /
+  transform hook in TurnExecutor's RECORD phase. Runs after the
+  command is parsed but before the audit row is committed. Returning
+  an object with `state: "failed"` (or `"cancelled"`) short-circuits
+  recording and skips DISPATCH for that command. Plugins may also
+  return a transformed entry (modified body, attributes, path) for
+  the recorder to commit. Filter signature:
+  `(entry, { store, runId, turn, loopId, mode })`.
 
 ## Rejections (ask mode only)
 

package/src/plugins/policy/policy.js

@@ -1,39 +1,28 @@
 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,
-		});
+	#fail(entry, body) {
+		return { ...entry, body, state: "failed", outcome: "permission" };
 	}
 
 	async #enforceAskMode(entry, ctx) {
 		if (ctx.mode !== "ask") return entry;
 
 		if (entry.scheme === "sh") {
-			await this.#reject(ctx, "Rejected <sh> in ask mode");
-			return { ...entry, state: "failed", outcome: "permission" };
+			return this.#fail(entry, "Rejected <sh> in ask mode");
 		}
 
 		if (entry.scheme === "set" && entry.attributes?.path) {
 			const scheme = Entries.scheme(entry.attributes.path);
 			if (scheme === null && entry.body) {
-				await this.#reject(
-					ctx,
+				return this.#fail(
+					entry,
 					`Rejected file edit to ${entry.attributes.path} in ask mode`,
 				);
-				return { ...entry, state: "failed", outcome: "permission" };
 			}
 		}
 
@@ -41,19 +30,17 @@ export default class Policy {
 			const pathAttr = entry.attributes?.path || entry.path;
 			const scheme = Entries.scheme(pathAttr);
 			if (scheme === null) {
-				await this.#reject(ctx, `Rejected file rm of ${pathAttr} in ask mode`);
-				return { ...entry, state: "failed", outcome: "permission" };
+				return this.#fail(entry, `Rejected file rm of ${pathAttr} in ask mode`);
 			}
 		}
 
 		if (entry.scheme === "mv" || entry.scheme === "cp") {
 			const destScheme = Entries.scheme(entry.attributes?.to);
 			if (destScheme === null) {
-				await this.#reject(
-					ctx,
+				return this.#fail(
+					entry,
 					`Rejected ${entry.scheme} to file ${entry.attributes?.to} in ask mode`,
 				);
-				return { ...entry, state: "failed", outcome: "permission" };
 			}
 		}