@possumtech/rummy 0.5.0 → 2.0.1

package/src/agent/ResponseHealer.js

@@ -1,241 +0,0 @@
-const MAX_STALLS = Number(process.env.RUMMY_MAX_STALLS) || 3;
-const MIN_CYCLES = Number(process.env.RUMMY_MIN_CYCLES) || 3;
-const MAX_CYCLE_PERIOD = Number(process.env.RUMMY_MAX_CYCLE_PERIOD) || 4;
-const MAX_UPDATE_REPEATS = Number(process.env.RUMMY_MAX_UPDATE_REPEATS) || 3;
-const MAX_PATH_STAGNATION =
-	Number(process.env.RUMMY_MAX_PATH_STAGNATION) || 5;
-
-/**
- * Build a stable fingerprint for a single recorded entry.
- * Uses scheme + original command target + all op-defining attributes.
- * Excludes body (content too granular; same operation ≠ same content).
- */
-function cmdFingerprint(entry) {
-	const attrs = { ...(entry.attributes ?? {}) };
-	delete attrs.body;
-	const target =
-		attrs.path ?? attrs.command ?? attrs.query ?? attrs.question ?? "";
-	delete attrs.path;
-	const extra = Object.keys(attrs)
-		.toSorted()
-		.filter((k) => attrs[k] != null)
-		.map((k) => `${k}=${attrs[k]}`)
-		.join(",");
-	return `${entry.scheme}:${target}${extra ? `[${extra}]` : ""}`;
-}
-
-/**
- * Detect a repeating cycle in the fingerprint history.
- * Checks periods 1..MAX_CYCLE_PERIOD for MIN_CYCLES consecutive repetitions.
- * Catches AAAA (period 1), ABABAB (period 2), ABCABCABC (period 3), etc.
- */
-function detectCycle(history) {
-	for (let k = 1; k <= MAX_CYCLE_PERIOD; k++) {
-		const needed = k * MIN_CYCLES;
-		if (history.length < needed) continue;
-		const tail = history.slice(-needed);
-		const cycle = tail.slice(0, k);
-		let match = true;
-		outer: for (let rep = 0; rep < MIN_CYCLES; rep++) {
-			for (let j = 0; j < k; j++) {
-				if (tail[rep * k + j] !== cycle[j]) {
-					match = false;
-					break outer;
-				}
-			}
-		}
-		if (match) return { detected: true, period: k, cycles: MIN_CYCLES };
-	}
-	return { detected: false };
-}
-
-/**
- * Extract the target paths a command touches for stagnation detection.
- * Same target logic as cmdFingerprint but returns the raw path for set
- * comparison across turns.
- */
-function cmdPaths(entry) {
-	const attrs = entry.attributes ?? {};
-	const paths = [];
-	if (attrs.path) paths.push(attrs.path);
-	if (attrs.to) paths.push(attrs.to);
-	if (attrs.command) paths.push(attrs.command);
-	if (attrs.query) paths.push(attrs.query);
-	if (attrs.question) paths.push(attrs.question);
-	return paths;
-}
-
-export default class ResponseHealer {
-	#stallCount = 0;
-	#turnHistory = [];
-	#lastUpdateText = null;
-	#updateRepeatCount = 0;
-	#pathRuns = new Map(); // path → consecutive turns touched
-
-	/**
-	 * Heal a missing status tag. Called when the model emits
-	 * neither <summarize/> nor <update/>.
-	 */
-	/**
-	 * Heal a missing status tag. Called when the model emits
-	 * neither <summarize/> nor <update/>.
-	 *
-	 * Plain text with no commands = the model answered. Treat as summary.
-	 * Commands with no status tag = the model is working. Treat as update.
-	 */
-	static healStatus(content, commands) {
-		const trimmed = content.trim();
-
-		// Detect malformed-glitch content — model attempted a tool invocation
-		// (native call, malformed XML, etc.) that the parser couldn't dispatch.
-		// This is NOT an answer; it's a glitch that deserves the 3-strikes
-		// stall path so the model can recover. Without this check, the model
-		// emits one malformed call and the run terminates after a single turn.
-		const looksGlitched = /<\|tool_call>|<tool_call\|>/.test(trimmed);
-
-		// No commands + plain text = answered. Treat as summary.
-		if (commands.length === 0 && trimmed && !looksGlitched) {
-			console.warn("[RUMMY] Healed: plain text response treated as summary");
-			return { summaryText: trimmed.slice(0, 500), updateText: null };
-		}
-
-		// Only write/unknown commands + no investigation tools = completed action.
-		// The model did the thing without saying <summarize>. Treat as summary.
-		const hasInvestigation = commands.some((c) =>
-			["get", "env", "search", "ask_user"].includes(c.name),
-		);
-		if (!hasInvestigation && commands.length > 0) {
-			const names = commands.map((c) => c.name).join(", ");
-			console.warn(
-				`[RUMMY] Healed: action-only response (${names}) treated as summary`,
-			);
-			return {
-				summaryText: trimmed.slice(0, 500) || "Done.",
-				updateText: null,
-			};
-		}
-
-		console.warn(
-			`[RUMMY] Healed: missing <update>/<summarize>. Tools: ${commands.map((c) => c.name).join(", ") || "none"}`,
-		);
-		return { summaryText: null, updateText: "..." };
-	}
-
-	/**
-	 * Detect cyclic tool patterns across turns.
-	 * Returns { continue: boolean, reason?: string }
-	 *
-	 * Appends this turn's fingerprint to history, then checks whether the
-	 * history ends in a repeating cycle of period 1..MAX_CYCLE_PERIOD with
-	 * at least MIN_CYCLES consecutive repetitions.
-	 *
-	 * Catches AAAA (period 1), ABABAB (period 2), ABCABC (period 3), etc.
-	 * Turns with no tool calls are skipped — they don't contribute to a cycle.
-	 */
-	assessRepetition({ actionCalls, writeCalls }) {
-		const commands = [...(actionCalls || []), ...(writeCalls || [])];
-		if (commands.length === 0) return { continue: true };
-
-		const fp = commands.map(cmdFingerprint).toSorted().join("|");
-		this.#turnHistory.push(fp);
-
-		const cycle = detectCycle(this.#turnHistory);
-		if (cycle.detected) {
-			const reason = `Cyclic tool pattern (period ${cycle.period}, ${cycle.cycles} repetitions)`;
-			console.warn(`[RUMMY] Loop detected: ${reason}. Force-completing.`);
-			return { continue: false, reason };
-		}
-
-		// Distinct-paths stagnation: the model might vary commands turn-to-turn
-		// (avoiding exact-cycle detection) but still churn on a single path.
-		// Track per-path consecutive touches; flag if any path is touched in
-		// MAX_PATH_STAGNATION consecutive turns. Catches semantic stagnation
-		// where the fingerprints differ in micro-detail but the work is stuck
-		// on one entry (e.g. endlessly re-setting/re-getting the same plan).
-		const touchedPaths = new Set();
-		for (const cmd of commands) {
-			for (const p of cmdPaths(cmd)) touchedPaths.add(p);
-		}
-		// Paths not touched this turn — run broken, remove from map.
-		for (const path of [...this.#pathRuns.keys()]) {
-			if (!touchedPaths.has(path)) this.#pathRuns.delete(path);
-		}
-		// Paths touched this turn — increment run.
-		for (const path of touchedPaths) {
-			this.#pathRuns.set(path, (this.#pathRuns.get(path) || 0) + 1);
-		}
-		for (const [path, run] of this.#pathRuns) {
-			if (run >= MAX_PATH_STAGNATION) {
-				const reason = `Path stagnation: ${path} touched ${run} consecutive turns`;
-				console.warn(`[RUMMY] ${reason}. Force-completing.`);
-				return { continue: false, reason };
-			}
-		}
-
-		return { continue: true };
-	}
-
-	/**
-	 * Assess whether the run should continue.
-	 *
-	 * Returns { continue: boolean, reason?: string }
-	 *
-	 * Rules:
-	 *   <summarize/> present → done (terminate)
-	 *   <summarize/> + failed actions → overridden to <update> (continue)
-	 *   <update/> present  → continue (model says it's working)
-	 *   neither present    → warn, increment stall counter, continue
-	 *   stall counter hits MAX_STALLS → force-complete
-	 */
-	assessProgress({ summaryText, updateText, statusHealed, flags }) {
-		if (summaryText) {
-			this.#stallCount = 0;
-			return { continue: false };
-		}
-
-		if (updateText && !statusHealed) {
-			this.#stallCount = 0;
-			// Track repeated update text — model stuck declaring readiness
-			// But if the model created new entries this turn, it's making
-			// progress even if the update text is the same.
-			const madeProgress = flags?.hasWrites || flags?.hasReads;
-			if (updateText === this.#lastUpdateText && !madeProgress) {
-				this.#updateRepeatCount++;
-				if (this.#updateRepeatCount >= MAX_UPDATE_REPEATS) {
-					const reason = `Same <update/> repeated ${this.#updateRepeatCount} turns: "${updateText.slice(0, 60)}"`;
-					console.warn(`[RUMMY] Stalled: ${reason}. Force-completing.`);
-					return { continue: false, reason };
-				}
-			} else {
-				this.#lastUpdateText = updateText;
-				this.#updateRepeatCount = 1;
-			}
-			return { continue: true };
-		}
-
-		// Healed or neither — model is glitching
-		this.#stallCount++;
-
-		if (this.#stallCount >= MAX_STALLS) {
-			const reason = `${this.#stallCount} turns with no <update/> or <summarize/>`;
-			console.warn(`[RUMMY] Stalled: ${reason}. Force-completing.`);
-			return { continue: false, reason };
-		}
-
-		console.warn(
-			`[RUMMY] No <update/> or <summarize/> (stall ${this.#stallCount}/${MAX_STALLS})`,
-		);
-		return { continue: true };
-	}
-
-	/**
-	 * Reset state for a new run or after resolution resume.
-	 */
-	reset() {
-		this.#stallCount = 0;
-		this.#turnHistory = [];
-		this.#lastUpdateText = null;
-		this.#updateRepeatCount = 0;
-		this.#pathRuns = new Map();
-	}
-}

package/src/llm/OpenAiClient.js

@@ -1,100 +0,0 @@
-import msg from "../agent/messages.js";
-
-export default class OpenAiClient {
-	#baseUrl;
-	#apiKey;
-
-	constructor(baseUrl, apiKey) {
-		this.#baseUrl = String(baseUrl || "").replace(/\/v1\/?$/, "");
-		this.#apiKey = apiKey || "";
-	}
-
-	async completion(messages, model, options = {}) {
-		const body = { model, messages, think: true };
-		if (options.temperature !== undefined)
-			body.temperature = options.temperature;
-
-		const timeout = Number(process.env.RUMMY_FETCH_TIMEOUT) || 30_000;
-		const timeoutSignal = AbortSignal.timeout(timeout);
-		const signal = options.signal
-			? AbortSignal.any([options.signal, timeoutSignal])
-			: timeoutSignal;
-
-		const headers = { "Content-Type": "application/json" };
-		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 msg = choice.message;
-			if (!msg) continue;
-
-			// Normalize reasoning
-			const parts = [msg.reasoning_content, msg.reasoning, msg.thinking].filter(
-				Boolean,
-			);
-			msg.reasoning_content =
-				parts.length > 0 ? [...new Set(parts)].join("\n") : null;
-
-			if (process.env.RUMMY_DEBUG === "true" && msg.reasoning_content) {
-				console.warn(
-					`[RUMMY] Reasoning (${msg.reasoning_content.length} chars): ${msg.reasoning_content.slice(0, 120)}`,
-				);
-			}
-		}
-
-		return data;
-	}
-
-	async getContextSize(_model) {
-		const timeout = Number(process.env.RUMMY_FETCH_TIMEOUT) || 30_000;
-		const headers = { "Content-Type": "application/json" };
-		if (this.#apiKey) headers.Authorization = `Bearer ${this.#apiKey}`;
-
-		// Try /props first — llama.cpp exposes runtime n_ctx here
-		try {
-			const propsResponse = await fetch(`${this.#baseUrl}/props`, {
-				headers,
-				signal: AbortSignal.timeout(timeout),
-			});
-			if (propsResponse.ok) {
-				const props = await propsResponse.json();
-				const runtimeCtx = props?.default_generation_settings?.n_ctx;
-				if (runtimeCtx) return runtimeCtx;
-			}
-		} catch {}
-
-		// Fall back to /v1/models for training context
-		const response = await fetch(`${this.#baseUrl}/v1/models`, {
-			headers,
-			signal: AbortSignal.timeout(timeout),
-		});
-		if (!response.ok) {
-			throw new Error(
-				msg("error.openai_models_failed", {
-					status: response.status,
-					baseUrl: this.#baseUrl,
-				}),
-			);
-		}
-		const data = await response.json();
-		const model = data.data?.[0];
-		const ctx = model?.meta?.n_ctx_train || model?.context_length;
-		if (!ctx) throw new Error(msg("error.openai_no_context_length"));
-		return ctx;
-	}
-}

package/src/llm/OpenRouterClient.js

@@ -1,100 +0,0 @@
-import msg from "../agent/messages.js";
-
-const DEFAULT_CONTEXT_SIZE = 131072;
-
-export default class OpenRouterClient {
-	#apiKey;
-	#baseUrl;
-
-	constructor(apiKey) {
-		this.#apiKey = apiKey;
-		this.#baseUrl = process.env.OPENROUTER_BASE_URL;
-	}
-
-	async completion(messages, model, options = {}) {
-		if (!this.#apiKey) throw new Error(msg("error.openrouter_api_key_missing"));
-		return this.#fetch(messages, model, options);
-	}
-
-	async #fetch(messages, model, options) {
-		const body = { model, messages, include_reasoning: true };
-		if (options.temperature !== undefined)
-			body.temperature = options.temperature;
-
-		const timeout = Number(process.env.RUMMY_FETCH_TIMEOUT) || 30_000;
-		const timeoutSignal = AbortSignal.timeout(timeout);
-		const signal = options.signal
-			? 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,
-		});
-
-		if (!response.ok) {
-			const error = await response.text();
-			if (response.status === 401 || response.status === 403) {
-				throw new Error(
-					msg("error.openrouter_auth", {
-						status: `${response.status} - ${error}`,
-					}),
-				);
-			}
-			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 parts = [
-				cm.reasoning_content,
-				cm.reasoning,
-				cm.thinking,
-				...(cm.reasoning_details || []).map((d) => d.text),
-			].filter(Boolean);
-			cm.reasoning_content =
-				parts.length > 0 ? [...new Set(parts)].join("\n") : null;
-		}
-
-		return data;
-	}
-
-	#contextCache = new Map();
-
-	async getContextSize(model) {
-		if (process.env.RUMMY_CONTEXT_SIZE)
-			return Number(process.env.RUMMY_CONTEXT_SIZE);
-
-		if (this.#contextCache.has(model)) return this.#contextCache.get(model);
-
-		try {
-			const res = await fetch(`${this.#baseUrl}/models`, {
-				headers: { Authorization: `Bearer ${this.#apiKey}` },
-				signal: AbortSignal.timeout(5000),
-			});
-			if (res.ok) {
-				const data = await res.json();
-				const entry = data.data?.find((m) => m.id === model);
-				if (entry?.context_length) {
-					this.#contextCache.set(model, entry.context_length);
-					return entry.context_length;
-				}
-			}
-		} catch {}
-
-		return DEFAULT_CONTEXT_SIZE;
-	}
-}

package/src/plugins/budget/recovery.js

@@ -1,47 +0,0 @@
-/**
- * Pure recovery state transition — exported for testing.
- *
- * @param {object|null} recovery  Current recovery state.
- * @param {{ assembledTokens: number, budgetRecovery?: { target: number, promptPath: string|null } }} result
- * @returns {{ next: object|null, action: null|'restore'|'hard413', promptPath: string|null }}
- */
-export function advanceRecovery(recovery, result) {
-	// Initialise or update recovery state from a new Turn Demotion event.
-	if (result.budgetRecovery) {
-		if (!recovery) {
-			recovery = {
-				target: result.budgetRecovery.target,
-				promptPath: result.budgetRecovery.promptPath,
-				strikes: 0,
-				lastTokens: result.assembledTokens,
-			};
-		} else {
-			// Re-overflow during recovery: tighten target, don't count as strike.
-			recovery = {
-				...recovery,
-				target: Math.min(recovery.target, result.budgetRecovery.target),
-			};
-		}
-	}
-
-	if (recovery === null) return { next: null, action: null, promptPath: null };
-
-	const current = result.assembledTokens;
-
-	if (current <= recovery.target) {
-		return { next: null, action: "restore", promptPath: recovery.promptPath };
-	}
-
-	const noProgress = current >= recovery.lastTokens && !result.budgetRecovery;
-	const strikes = noProgress ? recovery.strikes + 1 : 0;
-
-	if (strikes >= 3) {
-		return { next: null, action: "hard413", promptPath: null };
-	}
-
-	return {
-		next: { ...recovery, strikes, lastTokens: current },
-		action: null,
-		promptPath: null,
-	};
-}

package/src/plugins/instructions/preamble.md

@@ -1,45 +0,0 @@
-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/performed/README.md

@@ -1,15 +0,0 @@
-# performed
-
-Renders the `<performed>` section of the user message — the active loop's
-tool results and lifecycle signals.
-
-## Registration
-
-- **Filter**: `assembly.user` at priority 100
-
-## Behavior
-
-Filters turn_context rows where `category === "logging"` and
-`source_turn >= loopStartTurn`. Renders each entry chronologically
-with turn, status, summary, fidelity, and tokens. Empty on the first
-turn of a loop.

package/src/plugins/performed/performed.js

@@ -1,45 +0,0 @@
-export default class Performed {
-	#core;
-
-	constructor(core) {
-		this.#core = core;
-		core.filter("assembly.user", this.assemblePerformed.bind(this), 100);
-	}
-
-	async assemblePerformed(content, ctx) {
-		const entries = ctx.rows.filter(
-			(r) =>
-				r.category === "logging" &&
-				r.source_turn >= ctx.loopStartTurn &&
-				r.scheme !== "unknown",
-		);
-		if (entries.length === 0) return content;
-
-		const lines = entries.map((e) => renderToolTag(e));
-		return `${content}<performed>\n${lines.join("\n")}\n</performed>\n`;
-	}
-}
-
-function renderToolTag(entry) {
-	const attrs =
-		typeof entry.attributes === "string"
-			? JSON.parse(entry.attributes)
-			: entry.attributes;
-
-	const target = attrs?.path || attrs?.file || attrs?.command || "";
-	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
-	const status = entry.status ? ` status="${entry.status}"` : "";
-	const fidelity = entry.fidelity ? ` fidelity="${entry.fidelity}"` : "";
-	const tokens = entry.tokens ? ` tokens="${entry.tokens}"` : "";
-	const summary =
-		typeof attrs?.summary === "string"
-			? ` summary="${attrs.summary.slice(0, 80)}"`
-			: "";
-
-	const body = entry.body || null;
-
-	if (body) {
-		return `<${entry.scheme} path="${target}"${turn}${status}${summary}${fidelity}${tokens}>${body}</${entry.scheme}>`;
-	}
-	return `<${entry.scheme} path="${target}"${turn}${status}${summary}${fidelity}${tokens}/>`;
-}

package/src/plugins/previous/README.md

@@ -1,16 +0,0 @@
-# previous
-
-Renders the `<previous>` section of the system message — completed loop
-history from prior ask/act invocations on this run.
-
-## Registration
-
-- **Filter**: `assembly.system` at priority 200
-- **Condition**: Omitted when `loopStartTurn <= 1` (first loop has no history)
-
-## Behavior
-
-Filters turn_context rows where `category` is `logging` or `prompt`
-and `source_turn < loopStartTurn`. Renders each entry chronologically
-with turn, status, summary, fidelity, and tokens. The model can target
-these entries by path with `<set>` or `<rm>` to free context space.

package/src/plugins/previous/previous.js

@@ -1,56 +0,0 @@
-export default class Previous {
-	#core;
-
-	constructor(core) {
-		this.#core = core;
-		core.filter("assembly.system", this.assemblePrevious.bind(this), 200);
-	}
-
-	async assemblePrevious(content, ctx) {
-		if (ctx.loopStartTurn <= 1) return content;
-
-		const entries = ctx.rows
-			.filter(
-				(r) =>
-					(r.category === "logging" || r.category === "prompt") &&
-					r.source_turn < ctx.loopStartTurn,
-			)
-			.toSorted((a, b) => {
-				if (a.source_turn !== b.source_turn)
-					return a.source_turn - b.source_turn;
-				// Within the same turn: prompt first (cause before effect)
-				if (a.category === "prompt" && b.category !== "prompt") return -1;
-				if (b.category === "prompt" && a.category !== "prompt") return 1;
-				return 0;
-			});
-		if (entries.length === 0) return content;
-
-		const lines = await Promise.all(
-			entries.map((e) => renderToolTag(e, this.#core)),
-		);
-		return `${content}\n\n<previous>\n${lines.join("\n")}\n</previous>`;
-	}
-}
-
-async function renderToolTag(entry, _core) {
-	const attrs =
-		typeof entry.attributes === "string"
-			? JSON.parse(entry.attributes)
-			: entry.attributes;
-
-	const target = attrs?.path || attrs?.file || attrs?.command || "";
-	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
-	const status = entry.status ? ` status="${entry.status}"` : "";
-	const fidelity = entry.fidelity ? ` fidelity="${entry.fidelity}"` : "";
-	const tokens = entry.tokens ? ` tokens="${entry.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/README.md

@@ -1,16 +0,0 @@
-# progress
-
-Renders the `<progress>` section of the user message — bridges the
-current work log to the active prompt.
-
-## Registration
-
-- **Filter**: `assembly.user` at priority 200
-
-## Behavior
-
-Emits `<progress turn="N">` carrying token budget and fidelity stats.
-On continuation turns with current entries: "The above actions were
-performed in response to the following prompt:"
-
-Progress text is the tuning knob for model orientation between turns.