@possumtech/rummy 2.2.0 → 2.3.1

package/src/llm/errors.js

@@ -14,20 +14,15 @@ export function isContextExceededMessage(message) {
 }
 
 const ABORT_PATTERN = /\b(aborted|AbortError|TimeoutError)\b/;
-// `terminated` is undici's err.message when the underlying socket closes
-// mid-fetch (TLSSocket.onHttpSocketClose → Fetch.onAborted) — same lane
-// as ECONNRESET, just surfaced through a streaming-fetch path.
+// `terminated` = undici socket close mid-fetch (same lane as ECONNRESET).
 const GATEWAY_PATTERN =
 	/\b(502|504|ECONNREFUSED|ECONNRESET|ENOTFOUND|EHOSTUNREACH|ETIMEDOUT|EPIPE|ECONNABORTED|fetch failed|terminated)\b/i;
 const RATE_LIMIT_PATTERN = /\b429\b/;
 const STATUS_503_PATTERN = /\b503\b/;
 const STATUS_500_PATTERN = /\b500\b/;
-// llamacpp / OpenAI-compatible servers signal model-warmup with this body.
 const MODEL_WARMUP_PATTERN = /\bLoading model\b/i;
 
-// Returns "gateway" | "warmup" | "rate_limit" | "server" | null.
-// null = do not retry, propagate immediately. Operator/internal aborts,
-// auth failures, malformed-request errors, unknown shapes all fall here.
+// Returns "gateway" | "warmup" | "rate_limit" | "server" | null (don't retry).
 export function classifyTransient(err) {
 	if (!err || typeof err.message !== "string") return null;
 	const { message } = err;
@@ -36,7 +31,6 @@ export function classifyTransient(err) {
 	if (GATEWAY_PATTERN.test(message)) return "gateway";
 	if (RATE_LIMIT_PATTERN.test(message)) return "rate_limit";
 	if (STATUS_503_PATTERN.test(message)) {
-		// 503 + explicit warmup signal → wait it out.
 		if (MODEL_WARMUP_PATTERN.test(message)) return "warmup";
 		if (typeof err.body === "string" && MODEL_WARMUP_PATTERN.test(err.body)) {
 			return "warmup";
@@ -47,9 +41,7 @@ export function classifyTransient(err) {
 	return null;
 }
 
-// HTTP Retry-After: integer seconds (most common form). Returns
-// undefined for missing, malformed, or HTTP-date forms — callers
-// fall through to backoff in those cases.
+// HTTP Retry-After in seconds; undefined for missing/malformed/HTTP-date.
 export function parseRetryAfter(value) {
 	if (!value) return undefined;
 	const seconds = Number(value);

package/src/llm/openaiStream.js

@@ -1,39 +1,13 @@
 import { parseRetryAfter } from "./errors.js";
 
-/**
- * Shared streaming client for OpenAI-compatible /chat/completions endpoints.
- *
- * Provider plugins (openai, openrouter, ollama) construct the request body
- * and headers; this module handles the SSE parsing, accumulates deltas into
- * a non-streaming-shape response, and surfaces errors with the same ergonomics
- * as the previous fetch-then-json pattern.
- *
- * Streaming is preferred over non-streaming for two reasons:
- *
- *   1. Long-running completions through CDN proxies (e.g. Cloudflare's 100s
- *      origin-timeout) can't survive a non-streaming hold; streaming keeps
- *      the connection alive byte-by-byte.
- *   2. Future UI surfaces ("thinking" displays) want the deltas live; a
- *      streaming-first plugin layer gives them a hook.
- *
- * The xAI Responses API (`/v1/responses`) uses a different streaming format
- * and is out of scope for this client.
- */
-
-/**
- * @param {Object} args
- * @param {string} args.url            Full POST URL (e.g. `${baseUrl}/v1/chat/completions`).
- * @param {Object} args.headers        Plugin-specific headers (Authorization, etc.).
- * @param {Object} args.body           Request body (without `stream` — added here).
- * @param {AbortSignal} [args.signal]  Cancellation signal.
- * @returns {Promise<Object>}          Non-streaming-shape response: `{ choices, usage, model }`.
- *                                     Throws on non-2xx with `err.status` and `err.body` populated.
- */
+// SSE client for OpenAI-compatible /chat/completions. Streaming keeps
+// long completions alive through CDN proxies (Cloudflare's 100s timeout).
+// Returns non-streaming shape { choices, usage, model, chunkMetadata };
+// throws on non-2xx with err.status / err.body / err.retryAfter.
 export async function chatCompletionStream({ url, headers, body, signal }) {
 	const requestBody = {
 		...body,
 		stream: true,
-		// Tells OpenAI / OpenAI-compatible servers to emit a final usage chunk.
 		stream_options: { include_usage: true },
 	};
 
@@ -62,21 +36,13 @@ export async function chatCompletionStream({ url, headers, body, signal }) {
 	let usage = null;
 	let model = null;
 	let finishReason = null;
-	// Catch-all for chunk-level metadata that isn't `choices` or `usage` —
-	// id, system_fingerprint, service_tier, created, object, plus any
-	// provider-specific fields. The last-seen wins (these are typically
-	// stable across chunks; xAI/OpenAI repeat them, some land only on the
-	// final chunk).
+	// Last-seen wins for catch-all chunk fields (id, system_fingerprint, etc).
 	const chunkMetadata = {};
 
 	while (true) {
 		const { done, value } = await reader.read();
 		if (done) break;
 		buffer += decoder.decode(value, { stream: true });
-
-		// SSE frames are separated by blank lines; within a frame, a `data:`
-		// line carries the JSON payload. Process complete lines and keep any
-		// trailing partial-line in the buffer for the next read.
 		const lines = buffer.split("\n");
 		buffer = lines.pop();
 
@@ -96,11 +62,6 @@ export async function chatCompletionStream({ url, headers, body, signal }) {
 			if (chunk.model) model = chunk.model;
 			if (chunk.usage) usage = chunk.usage;
 
-			// Capture every non-content field the provider sends. We strip
-			// `choices` (handled below) and `usage` (already extracted) and
-			// keep the rest verbatim. Fields seen in a later chunk overwrite
-			// earlier ones — providers re-emit stable fields, and final-chunk
-			// fields (system_fingerprint on some, service_tier on others) win.
 			for (const [k, v] of Object.entries(chunk)) {
 				if (k === "choices" || k === "usage") continue;
 				chunkMetadata[k] = v;
@@ -113,8 +74,7 @@ export async function chatCompletionStream({ url, headers, body, signal }) {
 			const delta = choice.delta;
 			if (!delta) continue;
 			if (typeof delta.content === "string") content += delta.content;
-			// Different providers surface reasoning under different field names.
-			// Concatenate any that show up.
+			// Reasoning surfaces under different field names per provider.
 			if (typeof delta.reasoning_content === "string")
 				reasoningContent += delta.reasoning_content;
 			if (typeof delta.reasoning === "string")

package/src/plugins/ask_user/ask_user.js

@@ -1,10 +1,11 @@
-import { SUMMARY_MAX_CHARS } from "../helpers.js";
+import {
+	projectEmission,
+	SUMMARY_MAX_CHARS,
+	summarizeEmission,
+} from "../helpers.js";
 import docs from "./ask_userDoc.js";
 
-// Per-side cap for the "question → answer" summary projection. Splitting
-// before the arrow preserves the structural separator the model uses to
-// read the pair as a unit; a single trailing slice could lose the arrow
-// entirely when either side is large.
+// Per-side cap so summary preserves the arrow separator on long Q/A.
 const ARROW = " → ";
 const HALF = Math.floor((SUMMARY_MAX_CHARS - ARROW.length) / 2);
 
@@ -36,14 +37,12 @@ export default class AskUser {
 			runId: ctx.runId,
 			turn,
 			path: ctx.path,
-			body: ctx.resolvedBody,
 			attributes: { ...ctx.attrs, answer: ctx.output },
 		});
 	}
 
 	async handler(entry, rummy) {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
-		// XmlParser resolved question/options from attr-or-body already.
 		const { question, options: rawOptions } = entry.attributes;
 
 		let options = [];
@@ -59,7 +58,7 @@ export default class AskUser {
 			runId,
 			turn,
 			path: entry.resultPath,
-			body: entry.body,
+			body: "",
 			state: "proposed",
 			attributes: { question, options },
 			loopId,
@@ -67,18 +66,14 @@ export default class AskUser {
 	}
 
 	full(entry) {
-		const { question, answer } = entry.attributes;
-		const lines = ["# ask_user"];
-		if (question) lines.push(`# Question: ${question}`);
-		if (answer) lines.push(`# Answer: ${answer}`);
-		return lines.join("\n");
+		return projectEmission(entry.body);
 	}
 
 	summary(entry) {
 		const { question, answer } = entry.attributes;
-		if (answer) {
-			return `${question.slice(0, HALF)}${ARROW}${answer.slice(0, HALF)}`;
-		}
-		return question.slice(0, SUMMARY_MAX_CHARS);
+		const text = answer
+			? `${question.slice(0, HALF)}${ARROW}${answer.slice(0, HALF)}`
+			: question.slice(0, SUMMARY_MAX_CHARS);
+		return summarizeEmission(text);
 	}
 }

package/src/plugins/budget/README.md

@@ -9,6 +9,44 @@ Ceiling = `floor(contextSize × RUMMY_BUDGET_CEILING)` (default 0.9). The
 handling. No per-write gating — tools run uninterrupted. Enforcement
 happens at one boundary: the pre-LLM grinder.
 
+## Single source of truth
+
+`tokenUsage` and `tokensFree` are one number derived from one helper:
+
+```js
+computePacketTokens({ system, user })
+  → tokenUsage = countTokens(system) + countTokens(user)
+```
+
+This is what the **`<budget>`** tag shows the model AND what the
+`turn.beforeDispatch` enforce gate measures (when no prior-turn
+`prompt_tokens` is available; otherwise enforce uses that real API
+count). The two never diverge — they reach for the same function
+against the same assembled bytes.
+
+## How `<budget>` is rendered
+
+`assembleBudget` runs at `assembly.user` priority 90. It emits the
+breakdown table (per-scheme `aTokens` sums) and writes the
+**placeholder** `<budget>` tag:
+
+```
+<budget tokenUsage="{{tokenUsage}}" tokensFree="{{tokensFree}}">
+… per-scheme breakdown table …
+System: {{systemTokens}} tokens.
+Total: …
+</budget>
+```
+
+`ContextAssembler.assembleFromTurnContext` then assembles both
+messages, calls `computePacketTokens`, and substitutes the placeholders
+in-place. Single pass: assemble → measure → substitute → return.
+
+The breakdown table values (per-scheme `aTokens`, summarized aggregate,
+visible/summarized counts) are independent of the headline math. They
+come from row-level measurements done at materialization time. The
+headline is wire truth; the table is the action map.
+
 ## Enforcement Points
 
 1. **Pre-LLM grinder** (`turn.beforeDispatch` filter): four-step
@@ -34,15 +72,15 @@ happens at one boundary: the pre-LLM grinder.
 ## Files
 
 - **budget.js** — Plugin. Math (`ceiling`, `measureMessages`,
-  `measureRows`, `computeBudget`), 413 body shaper (`overflowBody`),
-  and the plugin class itself.
+  `measureRows`, `computeBudget`, **`computePacketTokens`**), 413
+  body shaper (`overflowBody`), and the plugin class itself.
 
 ## Hook participation
 
-- `core.filter("turn.beforeDispatch", ...)` — pre-LLM grinder. Returns
-  the (possibly demoted) packet with `ok` / `overflow` flags.
-- `core.filter("assembly.user", ..., 175)` — renders the `<budget>`
-  table into the user message.
+- `core.filter("turn.beforeDispatch", ...)` — pre-LLM grinder.
+  Returns the (possibly demoted) packet with `ok` / `overflow` flags.
+- `core.filter("assembly.user", ..., 90)` — renders the `<budget>`
+  table + placeholder tag into the user message.
 
-Emits 413 errors through the unified error channel (`hooks.error.log.emit`);
-there is no separate `budget://` scheme.
+Emits 413 errors through the unified error channel
+(`hooks.error.log.emit`); there is no separate `budget://` scheme.

package/src/plugins/budget/budget.js

@@ -3,21 +3,26 @@ import { countTokens } from "../../agent/tokens.js";
 
 const CEILING_RATIO = Number(process.env.RUMMY_BUDGET_CEILING);
 
+// Substituted post-assembly by ContextAssembler with the headline numbers.
+export const TOKEN_USAGE_PLACEHOLDER = "{{tokenUsage}}";
+export const TOKENS_FREE_PLACEHOLDER = "{{tokensFree}}";
+
 export function ceiling(contextSize) {
 	return Math.floor(contextSize * CEILING_RATIO);
 }
 
-// Sum assembled-message token counts; used by the enforce gate.
 export function measureMessages(messages) {
 	return messages.reduce((sum, m) => sum + countTokens(m.content), 0);
 }
 
-// Sum projected row body token counts; used by prompt.js pre-assembly.
 export function measureRows(rows) {
 	return rows.reduce((sum, r) => sum + countTokens(r.body), 0);
 }
 
-// Single source of truth for budget numbers; tokenUsage echoes totalTokens for the wire attribute.
+export function computePacketTokens({ system = "", user = "" } = {}) {
+	return countTokens(system) + countTokens(user);
+}
+
 export function computeBudget({ contextSize, totalTokens }) {
 	const cap = ceiling(contextSize);
 	const tokensFree = Math.max(0, cap - totalTokens);
@@ -32,7 +37,12 @@ export function computeBudget({ contextSize, totalTokens }) {
 	};
 }
 
-// 413 error body; wire format is part of the model contract.
+export function substituteBudgetPlaceholders(text, { tokenUsage, tokensFree }) {
+	return text
+		.replaceAll(TOKEN_USAGE_PLACEHOLDER, String(tokenUsage))
+		.replaceAll(TOKENS_FREE_PLACEHOLDER, String(tokensFree));
+}
+
 export function overflowBody(overflow, contextSize, demoted) {
 	const cap = ceiling(contextSize);
 	const size = cap + overflow;
@@ -57,10 +67,6 @@ export default class Budget {
 		core.filter("assembly.user", this.assembleBudget.bind(this), 90);
 	}
 
-	// Filter participant. Receives the assembled packet; returns a
-	// (possibly modified) packet. The pre-LLM grinder demotes-and-
-	// rechecks per SPEC §budget_enforcement; if it can't fit after the
-	// ladder runs, sets ok=false so TurnExecutor short-circuits.
 	async #onBeforeDispatch(packet, ctxBag) {
 		return this.enforce({
 			contextSize: packet.contextSize,
@@ -72,19 +78,17 @@ export default class Budget {
 		});
 	}
 
-	// Renders <budget> at priority 275; see SPEC #token_accounting.
+	// Renders <budget> with placeholder headline numbers; ContextAssembler
+	// post-substitutes them after measuring the assembled packet.
 	assembleBudget(content, ctx) {
-		const { rows, contextSize, systemPrompt } = ctx;
+		const { rows, contextSize } = ctx;
 		if (!contextSize) return content;
 
 		const cap = ceiling(contextSize);
 
 		const byScheme = new Map();
 		let visibleCount = 0;
-		let premiumTokens = 0;
 		let summarizedCount = 0;
-		let _summarizedTokens = 0;
-		let floorTokens = 0;
 
 		const schemeEntry = (s) => {
 			let e = byScheme.get(s);
@@ -112,22 +116,13 @@ export default class Budget {
 				entry.visIfSumTokens += r.sTokens;
 				entry.premium += r.aTokens;
 				visibleCount += 1;
-				premiumTokens += r.aTokens;
-				floorTokens += r.sTokens;
 			} else if (r.visibility === "summarized") {
 				entry.sum += 1;
 				entry.sumTokens += r.sTokens;
 				summarizedCount += 1;
-				_summarizedTokens += r.sTokens;
-				floorTokens += r.sTokens;
 			}
 		}
 
-		const systemTokens = countTokens(systemPrompt);
-		const tokenUsage = floorTokens + premiumTokens + systemTokens;
-		const tokensFree = Math.max(0, cap - tokenUsage);
-
-		// Sort by current cost desc so biggest-impact rows are top.
 		const schemeRows = [...byScheme.entries()]
 			.toSorted(
 				([, a], [, b]) =>
@@ -139,17 +134,13 @@ export default class Budget {
 				return `| ${scheme} | ${e.vis} | ${e.sum} | ${cost} | ${ifAllSum} | ${e.premium} |`;
 			});
 
-		const systemPct =
-			tokenUsage > 0 ? Math.round((systemTokens / tokenUsage) * 100) : 0;
-
 		const table = [
 			"| scheme | vis | sum | cost | if-all-sum | premium |",
 			"|---|---|---|---|---|---|",
 			...schemeRows,
 		].join("\n");
 
-		const systemLine = `System: ${systemTokens} tokens (${systemPct}% of budget).`;
-		const totalLine = `Total: ${visibleCount} visible + ${summarizedCount} summarized entries; tokenUsage ${tokenUsage} / ceiling ${cap}. ${tokensFree} tokens free.`;
+		const totalLine = `Total: ${visibleCount} visible + ${summarizedCount} summarized entries; tokenUsage ${TOKEN_USAGE_PLACEHOLDER} / ceiling ${cap}. ${TOKENS_FREE_PLACEHOLDER} tokens free.`;
 		const legend = [
 			"Columns:",
 			"- cost: current cost of this scheme (vTokens for visible + sTokens for summarized)",
@@ -157,7 +148,7 @@ export default class Budget {
 			"- premium: savings from demoting visible → summarized (cost − if-all-sum)",
 		].join("\n");
 
-		return `${content}<budget tokenUsage="${tokenUsage}" tokensFree="${tokensFree}">\n${table}\n\n${legend}\n${systemLine}\n${totalLine}\n</budget>\n`;
+		return `${content}<budget tokenUsage="${TOKEN_USAGE_PLACEHOLDER}" tokensFree="${TOKENS_FREE_PLACEHOLDER}">\n${table}\n\n${legend}\n${totalLine}\n</budget>\n`;
 	}
 
 	#check({ contextSize, messages, rows, lastPromptTokens = 0 }) {
@@ -204,16 +195,7 @@ export default class Budget {
 		);
 	}
 
-	// Pre-LLM grinder ladder. SPEC §budget_enforcement.
-	//
-	//   1. Check budget. ok → return.
-	//   2. Soft 413: demote (current_turn − 1) visible. Recheck.
-	//   3. Soft 413: demote current prompt. Recheck.
-	//   4. Hard 413: emit and return ok=false.
-	//
-	// Every step that demotes anything emits a 413 error://. Soft 413s
-	// keep the run alive (turn proceeds to LLM); the hard 413 bubbles
-	// through to AgentLoop.
+	// Pre-LLM grinder ladder; SPEC §budget_enforcement.
 	async enforce({
 		contextSize,
 		messages,
@@ -226,7 +208,6 @@ export default class Budget {
 			return { messages, rows, assembledTokens: 0, ok: true };
 		}
 
-		// Step 1.
 		const first = this.#check({
 			contextSize,
 			messages,
@@ -237,7 +218,7 @@ export default class Budget {
 
 		const store = rummy.entries;
 
-		// Step 2: previous-turn demotion.
+		// Step 1: previous-turn demotion.
 		const prevTurn = ctx.turn - 1;
 		const rawTurnDemoted =
 			prevTurn >= 0 ? await store.demoteTurnEntries(ctx.runId, prevTurn) : [];
@@ -274,7 +255,7 @@ export default class Budget {
 			first.overflow = rechecked.overflow;
 		}
 
-		// Step 3: current-prompt demotion.
+		// Step 2: current-prompt demotion.
 		const promptRow = rows.findLast(
 			(r) => r.category === "prompt" && r.scheme === "prompt",
 		);
@@ -320,7 +301,7 @@ export default class Budget {
 			first.overflow = rechecked.overflow;
 		}
 
-		// Step 4: hard 413.
+		// Hard 413.
 		const allDemoted = [...turnDemoted, ...promptDemoted];
 		await this.#emit({
 			message: overflowBody(first.overflow, contextSize, allDemoted),

package/src/plugins/cp/cp.js

@@ -1,5 +1,10 @@
 import Entries from "../../agent/Entries.js";
-import { storePatternResult } from "../helpers.js";
+import { countTokens } from "../../agent/tokens.js";
+import {
+	projectEmission,
+	storePatternResult,
+	summarizeEmission,
+} from "../helpers.js";
 import docs from "./cpDoc.js";
 
 export default class Cp {
@@ -25,7 +30,6 @@ export default class Cp {
 			? entry.attributes.visibility
 			: undefined;
 
-		// Manifest: list what would be copied without performing the cp.
 		if (entry.attributes.manifest !== undefined) {
 			const matches = await store.getEntriesByPattern(runId, path);
 			await storePatternResult(store, runId, turn, "cp", path, null, matches, {
@@ -38,9 +42,7 @@ export default class Cp {
 
 		const source = await store.getBody(runId, path);
 		if (source === null) return;
-		// Tags propagate: explicit `tags=` on the cp wins; otherwise the
-		// destination inherits the source entry's tags. Same shape as
-		// visibility — explicit attr overrides, default inherits.
+		// Tags: explicit attr wins; otherwise destination inherits source's.
 		let destTags = null;
 		if (typeof entry.attributes.tags === "string") {
 			destTags = entry.attributes.tags;
@@ -56,19 +58,18 @@ export default class Cp {
 		const warning =
 			existing !== null ? `Overwrote existing entry at ${to}` : null;
 
-		const body = `${path} ${to}`;
+		const sourceTokens = countTokens(source);
+		const destOldTokens = existing !== null ? countTokens(existing) : 0;
+		const beforeTokens = sourceTokens + destOldTokens;
+		const afterTokens = sourceTokens * 2;
+
 		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 proposal accepted but no
-			// file landed — the model's "<cp src dest> then <set dest>
-			// SEARCH/REPLACE" sequence silently no-op'd at materialize.
+			// Bare-file: hand the shared set.js materializer attrs.patched.
 			await store.set({
 				runId,
 				turn,
 				path: entry.resultPath,
-				body,
+				body: "",
 				state: "proposed",
 				attributes: {
 					from: path,
@@ -78,6 +79,8 @@ export default class Cp {
 					path: to,
 					patched: source,
 					visibility,
+					beforeActionTokens: beforeTokens,
+					afterActionTokens: afterTokens,
 				},
 				loopId,
 			});
@@ -96,19 +99,26 @@ export default class Cp {
 				runId,
 				turn,
 				path: entry.resultPath,
-				body,
+				body: "",
 				state: "resolved",
-				attributes: { from: path, to, isMove: false, warning },
+				attributes: {
+					from: path,
+					to,
+					isMove: false,
+					warning,
+					beforeActionTokens: beforeTokens,
+					afterActionTokens: afterTokens,
+				},
 				loopId,
 			});
 		}
 	}
 
 	full(entry) {
-		return `# cp ${entry.attributes.from} ${entry.attributes.to}`;
+		return projectEmission(entry.body);
 	}
 
-	summary() {
-		return "";
+	summary(entry) {
+		return summarizeEmission(entry.body);
 	}
 }

package/src/plugins/env/env.js

@@ -1,4 +1,9 @@
-import { logPathToDataBase, streamSummary } from "../helpers.js";
+import {
+	logPathToDataBase,
+	projectEmission,
+	streamSummary,
+	summarizeEmission,
+} from "../helpers.js";
 import docs from "./envDoc.js";
 
 const LOG_ACTION_RE = /^log:\/\/turn_\d+\/(\w+)\//;
@@ -8,10 +13,7 @@ export default class Env {
 
 	constructor(core) {
 		this.#core = core;
-		// env vs sh: env is read-only (allowed in ask-mode); see plugin README.
-		// Streaming stdout/stderr is time-indexed activity output, not
-		// topic-indexed state — category="logging" so it renders in <log>
-		// adjacent to its action entry, not in <summary>/<visible>.
+		// env is read-only (allowed in ask-mode); see plugin README.
 		core.registerScheme({ category: "logging" });
 		core.on("handler", this.handler.bind(this));
 		core.on("visible", this.full.bind(this));
@@ -46,7 +48,6 @@ export default class Env {
 			runId: ctx.runId,
 			path: ctx.path,
 			state: "resolved",
-			body: `ran '${command}' (in progress). Output: ${dataBase}_1, ${dataBase}_2`,
 		});
 	}
 
@@ -63,11 +64,14 @@ export default class Env {
 		});
 	}
 
+	// log:// entries: emission, tab-indented. env:// entries: stream bytes verbatim.
 	full(entry) {
-		return `# env ${entry.attributes.command}\n${entry.body}`;
+		if (entry.path.startsWith("log://")) return projectEmission(entry.body);
+		return entry.body;
 	}
 
 	summary(entry) {
+		if (entry.path.startsWith("log://")) return summarizeEmission(entry.body);
 		return streamSummary("env", entry);
 	}
 }