@possumtech/rummy 2.1.0 → 2.2.1

package/src/plugins/instructions/instructions.js

@@ -1,144 +1,86 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import Protocol from "./protocol.js";
 
+// Base system-prompt content (header + Core XML Command Grammar). The
+// `[%TOOLS%]` placeholder is substituted with the active-toolset tag list
+// at render time. Tool-specific docs no longer live here; they're a
+// separate `assembly.system` participant at priority 100.
 const baseInstructions = readFileSync(
-	new URL("./instructions.md", import.meta.url),
+	new URL("./instructions-system.md", import.meta.url),
 	"utf8",
 );
 
-// 1XY phase routing; see plugin README.
-const PHASES = [4, 5, 6, 7, 8, 9];
-const phaseInstructions = Object.fromEntries(
-	PHASES.flatMap((p) => {
-		const url = new URL(`./instructions_10${p}.md`, import.meta.url);
-		return existsSync(url) ? [[p, readFileSync(url, "utf8").trim()]] : [];
-	}),
-);
-const TURN_FROM_PATH = /^log:\/\/turn_(\d+)\/update\//;
-
-function phaseForStatus(status) {
-	if (status == null) return 4;
-	if (status === 200) return 7;
-	const last = status % 10;
-	return PHASES.includes(last) ? last : 4;
-}
+// Tight, non-modal reminder rendered LATE in the user message
+// (`assembly.user` priority 165, between unknowns at 150 and budget at
+// 175) so the rules sit adjacent to the action site — recency keeps the
+// per-turn discipline warm.
+const userInstructions = readFileSync(
+	new URL("./instructions-user.md", import.meta.url),
+	"utf8",
+).trim();
 
-// Latest non-rejected update status from materialized rows.
-function latestUpdateStatusFromRows(rows) {
-	let bestTurn = -1;
-	let bestStatus = null;
-	for (const r of rows) {
-		const m = TURN_FROM_PATH.exec(r.path);
-		if (!m) continue;
-		const turn = Number(m[1]);
-		const attrs =
-			typeof r.attributes === "string"
-				? JSON.parse(r.attributes)
-				: r.attributes;
-		const status = attrs?.status;
-		if (status == null) continue;
-		if (attrs?.rejected) continue;
-		if (turn > bestTurn || (turn === bestTurn && status > bestStatus)) {
-			bestTurn = turn;
-			bestStatus = status;
-		}
-	}
-	return bestStatus;
-}
+const TURN_FROM_PATH = /^log:\/\/turn_(\d+)\/update\//;
 
 export default class Instructions {
 	#core;
 
 	constructor(core) {
 		this.#core = core;
-		core.on("visible", this.full.bind(this));
-		core.on("turn.started", this.onTurnStarted.bind(this));
-		core.hooks.instructions.resolveSystemPrompt =
-			this.resolveSystemPrompt.bind(this);
-		core.hooks.instructions.validateNavigation =
-			this.validateNavigation.bind(this);
 		core.hooks.instructions.findLatestSummary =
 			this.findLatestSummary.bind(this);
-		core.filter("assembly.user", this.assembleInstructions.bind(this), 200);
+		// System message: priority chain. Base header + grammar at 50,
+		// joined per-tool docs at 100, persona at 150 (in persona.js).
+		core.filter("assembly.system", this.assembleSystemBase.bind(this), 50);
+		core.filter("assembly.system", this.assembleSystemToolDocs.bind(this), 100);
+		// User message: per-turn reminder block at the front of the user
+		// packet — sets discipline before the prompt.
+		core.filter("assembly.user", this.assembleInstructions.bind(this), 30);
 		new Protocol(core);
 	}
 
-	// Project instructions://system through the visible view; called once per turn.
-	async resolveSystemPrompt(rummy) {
-		const { entries: store, runId, hooks } = rummy;
-		const entries = await store.getEntriesByPattern(
-			runId,
-			"instructions://system",
-			null,
-			{ includeAuditSchemes: true },
-		);
-		// The entry is always written by onTurnStarted before this runs.
-		const entry = entries[0];
-		const attributes = await store.getAttributes(
-			runId,
-			"instructions://system",
-		);
-		return hooks.tools.view("instructions", {
-			path: "instructions://system",
-			scheme: "instructions",
-			body: entry.body,
-			attributes,
-			visibility: "visible",
-			category: "system",
-		});
+	#activeToolSet(ctx) {
+		return ctx.toolSet
+			? new Set(ctx.toolSet)
+			: new Set(this.#core.hooks.tools.names);
 	}
 
-	// Reject illegal stage navigation; see plugin README.
-	async validateNavigation(status, rummy) {
-		const currentPhase = await this.#getCurrentPhase(rummy);
-		const nextPhase = phaseForStatus(status);
-		if (nextPhase > currentPhase + 1) {
-			return { ok: false, reason: "Illegal navigation attempt" };
-		}
-		if (status === 200 && currentPhase !== 7) {
-			return { ok: false, reason: "Illegal navigation attempt" };
-		}
-		if (nextPhase === 7) {
-			const visible = await this.#countVisiblePriorPrompts(rummy);
-			if (visible > 0) {
-				return {
-					ok: false,
-					reason: `Illegal navigation attempt: ${visible} visible prior prompts`,
-				};
-			}
-		}
-		return { ok: true };
+	// assembly.system @ 50 — header + Core XML Command Grammar with the
+	// advertised tool tag list substituted into the `[%TOOLS%]` slot.
+	assembleSystemBase(content, ctx) {
+		const activeTools = this.#activeToolSet(ctx);
+		const advertised = this.#core.hooks.tools.advertisedNames.filter((n) =>
+			activeTools.has(n),
+		);
+		const tools = advertised.map((n) => `<${n}/>`).join(", ");
+		return `${content}${baseInstructions.replace("[%TOOLS%]", tools)}`;
 	}
 
-	async #getCurrentPhase(rummy) {
-		// `**` not `*`: update slugs may contain URL-encoded `/`.
-		const updates = await rummy.entries.getEntriesByPattern(
-			rummy.runId,
-			"log://*/update/**",
-			null,
+	// assembly.system @ 100 — per-tool docs joined in tool-registration
+	// order. Each tool plugin contributes its block via the
+	// `instructions.toolDocs` sub-filter (registry-style: filter
+	// participants mutate a docsMap keyed by tool name).
+	async assembleSystemToolDocs(content, ctx) {
+		const activeTools = this.#activeToolSet(ctx);
+		const toolDocs = await this.#core.hooks.instructions.toolDocs.filter(
+			{},
+			{ toolSet: activeTools },
 		);
-		let bestTurn = -1;
-		let bestStatus = null;
-		for (const e of updates) {
-			const m = TURN_FROM_PATH.exec(e.path);
-			if (!m) continue;
-			const turn = Number(m[1]);
-			if (turn >= rummy.sequence) continue;
-			const attrs =
-				typeof e.attributes === "string"
-					? JSON.parse(e.attributes)
-					: e.attributes;
-			if (attrs?.rejected) continue;
-			if (attrs?.status == null) continue;
-			if (turn > bestTurn) {
-				bestTurn = turn;
-				bestStatus = attrs.status;
-			}
-		}
-		return phaseForStatus(bestStatus);
+		const docsText = this.#core.hooks.tools.names
+			.filter((n) => activeTools.has(n))
+			.filter((key) => toolDocs[key])
+			.map((key) => toolDocs[key])
+			.join("\n\n");
+		if (!docsText) return content;
+		return `${content}\n\n${docsText}`;
+	}
+
+	// assembly.user @ 165 — per-turn reminder, same body every turn.
+	assembleInstructions(content, _ctx) {
+		return `${content}<instructions>\n${userInstructions}\n</instructions>\n`;
 	}
 
-	// Latest phase-7 success (status=200); state-machine knowledge lives here, not AgentLoop.
+	// Latest terminal update (status=200) — used by cli.js to print the
+	// run's final answer. State-machine knowledge lives here, not AgentLoop.
 	findLatestSummary(logEntries) {
 		return logEntries
 			.filter((e) => {
@@ -151,77 +93,4 @@ export default class Instructions {
 			})
 			.at(-1);
 	}
-
-	async #countVisiblePriorPrompts(rummy) {
-		const prompts = await rummy.entries.getEntriesByPattern(
-			rummy.runId,
-			"prompt://*",
-			null,
-		);
-		const visible = prompts.filter((p) => p.visibility === "visible");
-		if (visible.length === 0) return 0;
-		// Exclude the latest prompt; only PRIOR prompts trigger demote-before-Deployment.
-		let maxNum = -1;
-		for (const p of visible) {
-			const m = /^prompt:\/\/(\d+)$/.exec(p.path);
-			if (m && Number(m[1]) > maxNum) maxNum = Number(m[1]);
-		}
-		return visible.filter((p) => {
-			const m = /^prompt:\/\/(\d+)$/.exec(p.path);
-			return !m || Number(m[1]) !== maxNum;
-		}).length;
-	}
-
-	async onTurnStarted({ rummy }) {
-		const { entries: store, sequence: turn, runId } = rummy;
-		const runRow = await store.getRun(runId);
-		const toolSet = rummy.toolSet
-			? [...rummy.toolSet]
-			: this.#core.hooks.tools.names;
-		// instructions://system stays cache-stable; phase selection at assembly.user.
-		await store.set({
-			runId,
-			turn,
-			path: "instructions://system",
-			body: "",
-			state: "resolved",
-			writer: "system",
-			attributes: {
-				persona: runRow.persona,
-				toolSet,
-			},
-		});
-	}
-
-	async full(entry) {
-		const attrs = entry.attributes;
-		const activeTools = attrs.toolSet
-			? new Set(attrs.toolSet)
-			: new Set(this.#core.hooks.tools.names);
-		const toolDocs = await this.#core.hooks.instructions.toolDocs.filter(
-			{},
-			{ toolSet: activeTools },
-		);
-		const sorted = this.#core.hooks.tools.advertisedNames.filter((n) =>
-			activeTools.has(n),
-		);
-		const tools = sorted.map((n) => `<${n}/>`).join(", ");
-		const docsText = sorted
-			.filter((key) => toolDocs[key])
-			.map((key) => toolDocs[key])
-			.join("\n\n");
-		let prompt = baseInstructions
-			.replace("[%TOOLS%]", tools)
-			.replace("[%TOOLDOCS%]", docsText);
-		if (attrs.persona) prompt += `\n\n## Persona\n\n${attrs.persona}`;
-		return prompt;
-	}
-
-	// Render <instructions> for current phase; absent phase file → no block.
-	assembleInstructions(content, ctx) {
-		const status = latestUpdateStatusFromRows(ctx.rows);
-		const step = phaseInstructions[phaseForStatus(status)];
-		if (!step) return content;
-		return `${content}<instructions>\n${step}\n</instructions>\n`;
-	}
 }

package/src/plugins/known/README.md

@@ -1,7 +1,7 @@
 # known {#known_plugin}
 
 Writes knowledge entries into the store at full visibility, and renders
-the project's data surface as the bifurcated `<summarized>` /
+the project's data surface as the bifurcated `<summary>` /
 `<visible>` blocks at the top of the user message.
 
 ## Registration
@@ -10,7 +10,7 @@ the project's data surface as the bifurcated `<summarized>` /
 - **Category**: `data`
 - **Handler**: Upserts the entry body at the target path with status 200.
 - **Filters**:
-  - `assembly.user` priority 50 — renders `<summarized>`.
+  - `assembly.user` priority 50 — renders `<summary>`.
   - `assembly.user` priority 75 — renders `<visible>`.
 
 ## Projection
@@ -22,19 +22,18 @@ Shows `# known {path}` followed by the entry body.
 Filters `ctx.rows` where `category === "data"`. Two separate blocks
 emit at the top of the user message in this order:
 
-- `<summarized>` — each data entry whose visibility is `visible` or
+- `<summary>` — each data entry whose visibility is `visible` or
   `summarized`, rendered under its scheme tag with the plugin's
   summary projection as body (truncated knowns, code symbols,
   page abstracts — whatever the plugin's `summary()` hook produces).
-  Plus the named carve-out: archived prompts pass through
-  (visibility="archived") so the model can `<get>` the active prompt
-  back after demotion.
+  Archived entries — including prompts — are filtered out uniformly
+  (no carve-out).
 - `<visible>` — each data entry whose visibility is `visible`,
   rendered with the plugin's visible projection (full body) as the
   tag body. A visible entry appears in *both* blocks: summary
   projection up top, full body below.
 
-This split lets `<summarized>` stay cache-stable across promote/demote
+This split lets `<summary>` stay cache-stable across promote/demote
 operations — only `<visible>` mutates when the model promotes a
 summary or demotes a visible entry. Third-party plugins that register
 with `category: "data"` automatically appear in both blocks under

package/src/plugins/known/known.js

@@ -1,5 +1,6 @@
 import { stateToStatus } from "../../agent/httpStatus.js";
 import { countTokens } from "../../agent/tokens.js";
+import { renderEntry, SUMMARY_MAX_CHARS } from "../helpers.js";
 
 const MAX_ENTRY_TOKENS = Number(process.env.RUMMY_MAX_ENTRY_TOKENS);
 
@@ -8,13 +9,15 @@ export default class Known {
 
 	constructor(core) {
 		this.#core = core;
+		core.ensureTool();
 		core.registerScheme({ category: "data" });
 		core.on("handler", this.handler.bind(this));
 		core.on("visible", this.full.bind(this));
 		core.on("summarized", this.summary.bind(this));
-		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.filter("assembly.system", this.assembleSummarized.bind(this), 200);
+		core.filter("assembly.system", this.assembleVisible.bind(this), 250);
+		// Hidden from the advertised tool list — written via <set path="known://...">.
+		// The known:// scheme lifecycle is taught in instructions-user.md.
 		core.markHidden();
 	}
 
@@ -45,7 +48,7 @@ export default class Known {
 				runId,
 				"known",
 				entry.body,
-				entry.attributes?.summary,
+				entry.attributes?.tags,
 			);
 		}
 
@@ -80,11 +83,13 @@ export default class Known {
 		return entry.body;
 	}
 
-	// Summarized: first 500 chars; matches <prompt> summarized.
+	// Summarized: first SUMMARY_MAX_CHARS of the body. The model already
+	// knows summarized data is approximate (taught in instructions), so
+	// we don't owe it a "[truncated]" marker that would push the body
+	// past the contract floor.
 	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]`;
+		return entry.body.slice(0, SUMMARY_MAX_CHARS);
 	}
 
 	// Identity-keyed summary lines: every data entry the run is tracking
@@ -99,7 +104,7 @@ export default class Known {
 		const lines = entries.map((e) =>
 			renderContextTag(e, e.sBody != null ? e.sBody : e.body),
 		);
-		return `${content}<summarized>\n${lines.join("\n")}\n</summarized>\n`;
+		return `${content}<summary>\n${lines.join("\n")}\n</summary>\n`;
 	}
 
 	async assembleVisible(content, ctx) {
@@ -115,10 +120,6 @@ export default class Known {
 }
 
 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}"` : "";
-	const lines = entry.vLines != null ? ` lines="${entry.vLines}"` : "";
 	const attrs =
 		typeof entry.attributes === "string"
 			? JSON.parse(entry.attributes)
@@ -129,23 +130,16 @@ function renderContextTag(entry, projectedBody) {
 			: entry.state
 				? stateToStatus(entry.state, entry.outcome)
 				: null;
-	const status =
-		statusValue != null && statusValue !== 200
-			? ` status="${statusValue}"`
-			: "";
-	const stateAttr =
-		entry.state && entry.state !== "resolved" ? ` state="${entry.state}"` : "";
-	const outcomeAttr = entry.outcome ? ` outcome="${entry.outcome}"` : "";
-	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}`;
-	if (projectedBody) {
-		return `<${tag} path="${entry.path}"${attrStr}>${projectedBody}</${tag}>`;
+	const meta = {};
+	if (entry.source_turn) meta.turn = entry.source_turn;
+	if (statusValue != null && statusValue !== 200) meta.status = statusValue;
+	if (entry.state && entry.state !== "resolved") meta.state = entry.state;
+	if (entry.outcome) meta.outcome = entry.outcome;
+	if (typeof attrs?.tags === "string") {
+		meta.tags = attrs.tags.slice(0, 80);
 	}
-	return `<${tag} path="${entry.path}"${attrStr}/>`;
+	if (entry.visibility === "archived") meta.visibility = "archived";
+	if (entry.aTokens != null) meta.tokens = entry.aTokens;
+	if (entry.vLines != null) meta.lines = entry.vLines;
+	return renderEntry(entry.path, meta, projectedBody);
 }

package/src/plugins/log/log.js

@@ -1,4 +1,5 @@
 import { stateToStatus } from "../../agent/httpStatus.js";
+import { renderEntry } from "../helpers.js";
 
 // sh/env span multiple channels; channels render their own tokens in <visible>.
 const STREAM_NO_TOKENS = new Set(["sh", "env"]);
@@ -8,7 +9,7 @@ export default class Log {
 
 	constructor(core) {
 		this.#core = core;
-		core.filter("assembly.user", this.assembleLog.bind(this), 100);
+		core.filter("assembly.system", this.assembleLog.bind(this), 300);
 	}
 
 	async assembleLog(content, ctx) {
@@ -16,8 +17,13 @@ export default class Log {
 		const latestPrompt = ctx.rows.findLast(
 			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
+		// All time-indexed activity belongs here: log entries (actions,
+		// errors, updates) AND streaming data channels from env/sh which
+		// are also time-indexed. Visibility controls the body projection
+		// (vBody for visible, sBody for summarized) — not which section
+		// the entry lives in.
 		const entries = ctx.rows.filter((r) => {
-			if (r.category === "logging" && r.scheme === "log") return true;
+			if (r.category === "logging") return true;
 			if (r.category === "prompt" && r.scheme === "prompt") {
 				return r !== latestPrompt;
 			}
@@ -31,13 +37,30 @@ export default class Log {
 	}
 }
 
-// Action segment of log://turn_N/action/slug → XML tag.
+// Action label for the entry's <log> rendering. log://turn_N/<action>/<slug>
+// uses the path's action segment; env://turn_N/* and sh://turn_N/* are
+// streaming channels, so the scheme itself is the action.
 function actionFromPath(path) {
 	if (path?.startsWith("prompt://")) return "prompt";
+	if (path?.startsWith("env://")) return "env";
+	if (path?.startsWith("sh://")) return "sh";
 	const match = path?.match(/^log:\/\/turn_\d+\/([^/]+)\//);
 	return match ? match[1] : "log";
 }
 
+// Visibility controls projection within <log>: summarized entries render
+// the compact sBody; visible entries render the full vBody (or fall back
+// to the raw body when no projection exists).
+function projectedBody(entry) {
+	if (entry.visibility === "summarized" && entry.sBody != null) {
+		return entry.sBody;
+	}
+	if (entry.visibility === "visible" && entry.vBody != null) {
+		return entry.vBody;
+	}
+	return entry.body;
+}
+
 function renderLogTag(entry, rowsByPath) {
 	const attrs =
 		typeof entry.attributes === "string"
@@ -45,20 +68,12 @@ function renderLogTag(entry, rowsByPath) {
 			: entry.attributes;
 
 	const action = actionFromPath(entry.path);
-
 	const statusValue =
 		attrs?.status != null
 			? attrs.status
 			: entry.state
 				? stateToStatus(entry.state, entry.outcome)
 				: null;
-	// 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 = 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;
@@ -76,27 +91,21 @@ function renderLogTag(entry, rowsByPath) {
 		tokenSource = entry.aTokens;
 		lineSource = entry.vLines;
 	}
-	const tokens = tokenSource != null ? ` tokens="${tokenSource}"` : "";
-	const summary =
-		typeof attrs?.summary === "string"
-			? ` summary="${attrs.summary.slice(0, 80)}"`
-			: "";
-	const query =
-		typeof attrs?.query === "string" ? ` query="${attrs.query}"` : "";
-	const command =
-		typeof attrs?.command === "string" ? ` command="${attrs.command}"` : "";
-	const target = attrs?.path ? ` target="${attrs.path}"` : "";
-	// Slice reads emit lines="a-b/total"; others emit simple lines="N".
-	const lines = isSlice
-		? ` lines="${attrs.lineStart}-${attrs.lineEnd}/${attrs.totalLines}"`
-		: lineSource != null
-			? ` lines="${lineSource}"`
-			: "";
-
-	const attrStr = `${target}${status}${outcomeAttr}${query}${command}${summary}${lines}${tokens}`;
 
-	if (entry.body) {
-		return `<${action} path="${entry.path}"${attrStr}>${entry.body}</${action}>`;
+	const meta = { action };
+	if (attrs?.path) meta.target = attrs.path;
+	// Suppress status on prompts; uniform 200 carries no signal.
+	if (statusValue != null && action !== "prompt") meta.status = statusValue;
+	if (entry.outcome) meta.outcome = entry.outcome;
+	if (typeof attrs?.query === "string") meta.query = attrs.query;
+	if (typeof attrs?.command === "string") meta.command = attrs.command;
+	if (typeof attrs?.tags === "string") meta.tags = attrs.tags.slice(0, 80);
+	if (isSlice) {
+		meta.lines = `${attrs.lineStart}-${attrs.lineEnd}/${attrs.totalLines}`;
+	} else if (lineSource != null) {
+		meta.lines = lineSource;
 	}
-	return `<${action} path="${entry.path}"${attrStr}/>`;
+	if (tokenSource != null) meta.tokens = tokenSource;
+
+	return renderEntry(entry.path, meta, projectedBody(entry));
 }

package/src/plugins/mv/mv.js

@@ -1,4 +1,5 @@
 import Entries from "../../agent/Entries.js";
+import { storePatternResult } from "../helpers.js";
 import docs from "./mvDoc.js";
 
 const LOG_ACTION_RE = /^log:\/\/turn_\d+\/(\w+)\//;
@@ -34,6 +35,17 @@ export default class Mv {
 			? entry.attributes.visibility
 			: undefined;
 
+		// Manifest: list what would be affected without performing the mv.
+		if (entry.attributes.manifest !== undefined) {
+			const matches = await store.getEntriesByPattern(runId, path);
+			await storePatternResult(store, runId, turn, "mv", path, null, matches, {
+				manifest: true,
+				loopId,
+				attributes: { path, to },
+			});
+			return;
+		}
+
 		// Visibility-in-place: no destination, change visibility of matched entries
 		if (visibility && !to) {
 			const matches = await store.getEntriesByPattern(runId, path);
@@ -58,6 +70,18 @@ export default class Mv {
 
 		const source = await store.getBody(runId, path);
 		if (source === null) return;
+		// Tags propagate: explicit `tags=` on the mv wins; otherwise the
+		// destination inherits the source entry's tags. Same shape as
+		// visibility — explicit attr overrides, default inherits.
+		let destTags = null;
+		if (typeof entry.attributes.tags === "string") {
+			destTags = entry.attributes.tags;
+		} else {
+			const sourceAttrs = await store.getAttributes(runId, path);
+			if (sourceAttrs && typeof sourceAttrs.tags === "string") {
+				destTags = sourceAttrs.tags;
+			}
+		}
 
 		const destScheme = Entries.scheme(to);
 		const existing = await store.getBody(runId, to);
@@ -68,13 +92,27 @@ export default class Mv {
 
 		const body = `${path} ${to}`;
 		if (destScheme === null) {
+			// Bare-file destination: hand the shared materializer (set.js
+			// #materializeFile, gated on attrs.path + attrs.patched) the
+			// authoritative new body so it writes the source content to
+			// disk on accept. Without this the source rm fired but the
+			// destination was never created. Same shape as cp's bare-file
+			// branch.
 			await store.set({
 				runId,
 				turn,
 				path: entry.resultPath,
 				body,
 				state: "proposed",
-				attributes: { from: path, to, isMove: true, warning },
+				attributes: {
+					from: path,
+					to,
+					isMove: true,
+					warning,
+					path: to,
+					patched: source,
+					visibility,
+				},
 				loopId,
 			});
 		} else {
@@ -85,6 +123,7 @@ export default class Mv {
 				body: source,
 				state: "resolved",
 				visibility,
+				attributes: destTags ? { tags: destTags } : null,
 				loopId,
 			});
 			await store.rm({ runId: runId, path: path });

package/src/plugins/mv/mvDoc.md

@@ -1,10 +1,3 @@
 ## <mv path="[source]">[destination]</mv> - Move or rename a file or entry
-
-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="known://project/*" visibility="summarized"/>
-<!-- Batch visibility change via pattern. No destination = visibility in place. -->
+Example: <mv path="known://drafts/final_report.md">final_report.md</mv>

package/src/plugins/ollama/ollama.js

@@ -1,9 +1,9 @@
-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 } = config;
+const FETCH_TIMEOUT = Number(process.env.RUMMY_FETCH_TIMEOUT);
+const THINK = process.env.RUMMY_THINK === "1";
 
 const PROVIDER = "ollama";
 
@@ -28,7 +28,8 @@ export default class Ollama {
 	}
 
 	async #completion(messages, model, options = {}) {
-		const body = { model, messages, think: true };
+		const body = { model, messages, think: THINK };
+		if (options.maxTokens !== undefined) body.max_tokens = options.maxTokens;
 		if (options.temperature !== undefined)
 			body.temperature = options.temperature;