@possumtech/rummy 2.1.0 → 2.2.0

package/src/agent/known_queries.sql

@@ -1,7 +1,7 @@
 -- PREP: get_known_entries
 SELECT
 	path, scheme, state, outcome, visibility, body, turn, hash
-	, attributes, countTokens(body) AS tokens, scope, loop_id
+	, attributes, scope, loop_id, countTokens(body) AS tokens
 FROM known_entries
 WHERE run_id = :run_id
 ORDER BY path;

package/src/agent/known_store.sql

@@ -230,7 +230,7 @@ WHERE run_id = :run_id AND entry_id IN (
 -- by id (insertion order) for streaming consumers; otherwise by path.
 SELECT
 	e.id, e.path, e.body, e.scheme, rv.state, rv.outcome, rv.visibility, rv.turn
-	, countTokens(e.body) AS tokens, e.attributes
+	, e.attributes, countTokens(e.body) AS tokens
 FROM run_views AS rv
 JOIN entries AS e ON e.id = rv.entry_id
 JOIN schemes AS s ON s.name = COALESCE(e.scheme, 'file')
@@ -292,9 +292,7 @@ WHERE run_id = :run_id AND entry_id IN (
 -- matches the old RETURNING (path, tokens) for caller compatibility.
 -- State filter: skip failed/cancelled entries (they're already not
 -- contributing visible context — demoting them would be misleading).
--- Scheme filter: skip known/unknown — these are the model's deliverables,
--- not housekeeping. Auto-demoting just-created knowns punishes the
--- correct Distill+Demote pattern.
+-- All schemes participate uniformly per SPEC §budget_enforcement.
 SELECT e.path, countTokens(e.body) AS tokens
 FROM run_views AS rv
 JOIN entries AS e ON e.id = rv.entry_id
@@ -302,15 +300,12 @@ WHERE
 	rv.run_id = :run_id
 	AND rv.turn = :turn
 	AND rv.visibility = 'visible'
-	AND rv.state NOT IN ('failed', 'cancelled')
-	AND e.scheme NOT IN ('known', 'unknown');
+	AND rv.state NOT IN ('failed', 'cancelled');
 
 -- PREP: demote_turn_entries
 -- View-layer only — visibility lives on run_views. State untouched.
 -- Call get_turn_demotion_targets first if you need the list of what
 -- was demoted (used by budget plugin for the overflow error body).
--- Scheme filter mirrors get_turn_demotion_targets — never demote the
--- model's deliverables (known/unknown) along with housekeeping.
 UPDATE run_views
 SET
 	visibility = 'summarized'
@@ -319,38 +314,4 @@ WHERE
 	run_id = :run_id
 	AND turn = :turn
 	AND visibility = 'visible'
-	AND state NOT IN ('failed', 'cancelled')
-	AND NOT EXISTS (
-		SELECT 1
-		FROM entries AS e
-		WHERE
-			e.id = run_views.entry_id
-			AND e.scheme IN ('known', 'unknown')
-	);
-
--- PREP: get_run_visible_targets
--- All visible entries across the run, oldest promotion first. Used by
--- budget postDispatch as the fallback demotion set when this-turn
--- demotion yields nothing but the packet still overflows (promotions
--- from prior turns the model forgot to demote themselves).
-SELECT e.path, countTokens(e.body) AS tokens, rv.turn
-FROM run_views AS rv
-JOIN entries AS e ON e.id = rv.entry_id
-WHERE
-	rv.run_id = :run_id
-	AND rv.visibility = 'visible'
-	AND rv.state NOT IN ('failed', 'cancelled')
-ORDER BY rv.turn, e.id;
-
--- PREP: demote_run_visible
--- Broad cross-turn demotion. Separate prep from demote_turn_entries
--- so the caller's intent (surgical this-turn vs fallback all-visible)
--- stays explicit.
-UPDATE run_views
-SET
-	visibility = 'summarized'
-	, updated_at = CURRENT_TIMESTAMP
-WHERE
-	run_id = :run_id
-	AND visibility = 'visible'
 	AND state NOT IN ('failed', 'cancelled');

package/src/agent/materializeContext.js

@@ -1,10 +1,21 @@
+import { SUMMARY_MAX_CHARS } from "../plugins/helpers.js";
 import ContextAssembler from "./ContextAssembler.js";
 import { countLines, countTokens } from "./tokens.js";
 
+// Defensive cap: model-written summary projections (knowns, unknowns,
+// log actions, etc.) must produce ≤ SUMMARY_MAX_CHARS — the contract
+// floor for terse model-authored summaries. File-scheme entries are
+// exempt: their summarized projection is a structural derivative
+// (rummy.repo's symbol map), bounded by the file's actual complexity,
+// not by writer discipline. Truncating symbol data at 500 chars
+// destroys its utility. Files either render blank (no symbols
+// extracted) or render their full symbol map.
+
 // Rebuild turn_context from v_model_context and assemble messages.
 export default async function materializeContext({
 	db,
 	hooks,
+	entries,
 	runId,
 	loopId,
 	turn,
@@ -12,6 +23,7 @@ export default async function materializeContext({
 	mode,
 	toolSet,
 	contextSize,
+	persona = "",
 }) {
 	await db.clear_turn_context.run({ run_id: runId, turn });
 	const viewRows = await db.get_model_context.all({ run_id: runId });
@@ -37,10 +49,26 @@ export default async function materializeContext({
 			...baseEntry,
 			visibility: "visible",
 		});
-		const summarizedProjection = await hooks.tools.view(projectionKey, {
+		const rawSummarizedProjection = await hooks.tools.view(projectionKey, {
 			...baseEntry,
 			visibility: "summarized",
 		});
+		let summarizedProjection = rawSummarizedProjection;
+		if (
+			scheme !== "file" &&
+			typeof summarizedProjection === "string" &&
+			summarizedProjection.length > SUMMARY_MAX_CHARS
+		) {
+			summarizedProjection = summarizedProjection.slice(0, SUMMARY_MAX_CHARS);
+			await hooks.error.log.emit({
+				store: entries,
+				runId,
+				turn,
+				loopId,
+				message: `${row.path} summarized projection overflow`,
+				soft: true,
+			});
+		}
 		const vTokens = countTokens(visibleProjection);
 		const sTokens = countTokens(summarizedProjection);
 		const vLines = countLines(visibleProjection);
@@ -92,6 +120,7 @@ export default async function materializeContext({
 			toolSet,
 			lastContextTokens,
 			turn,
+			persona,
 		},
 		hooks,
 	);

package/src/agent/runs.sql

@@ -110,24 +110,14 @@ SELECT
 FROM run_views
 WHERE run_id = :parent_run_id;
 
--- PREP: archive_prior_prompt_artifacts
--- Multi-prompt sessions accumulate artifacts from prior prompt cycles
--- (consumed prompts, their per-turn logs). These pollute the validator's
--- prior-prompts check on subsequent Deployment landings. Archive all
--- prior prompt:// entries and prior-turn log:// entries when a new
--- prompt arrives. Knowns/unknowns/file entries are untouched — they
--- carry persistent knowledge across cycles. The loop_id IS NULL clause
--- catches forked-in views from a parent run (per fork_known_entries),
--- which represent prior cycles' artifacts inherited into a clean child.
-UPDATE run_views
-SET visibility = 'archived'
-WHERE run_id = :run_id
-	AND visibility != 'archived'
-	AND (turn < :current_turn OR loop_id IS NULL)
-	AND entry_id IN (
-		SELECT id FROM entries
-		WHERE scheme IN ('prompt', 'log')
-	);
+-- PREP: set_next_turn
+-- Forks inherit parent's next_turn so turn numbering is absolute
+-- across the lineage; the budget grinder's `current_turn - 1` rule
+-- then targets parent's last-turn promotions on the fork's first
+-- dispatch. See SPEC §budget_enforcement.
+UPDATE runs
+SET next_turn = :next_turn
+WHERE id = :run_id;
 
 -- PREP: get_active_runs
 SELECT r.id

package/src/agent/tokens.js

@@ -1,6 +1,5 @@
 // Conservative chars/token approximation; RUMMY_TOKEN_DIVISOR controls the divisor.
 const DIVISOR = Number(process.env.RUMMY_TOKEN_DIVISOR);
-if (!DIVISOR) throw new Error("RUMMY_TOKEN_DIVISOR must be a non-zero number");
 
 export function countTokens(text) {
 	if (!text) return 0;

package/src/agent/turns.sql

@@ -14,6 +14,7 @@ SET
 	, reasoning_tokens = :reasoning_tokens
 	, total_tokens = :total_tokens
 	, cost = :cost
+	, response_metadata = :response_metadata
 WHERE id = :id;
 
 -- PREP: get_run_usage

package/src/hooks/Hooks.js

@@ -48,6 +48,14 @@ export default function createHooks(debug = false) {
 			step: {
 				completed: createEvent("run.step.completed"),
 			},
+			// Fire-and-forget wake: any plugin that wants to deliver a new
+			// prompt onto a (possibly dormant) run emits with
+			// {runAlias, body, mode}. AgentLoop subscribes and runs inject —
+			// writes prompt://<nextTurn>, enqueues a loop, ensures the
+			// drainer is up. This is the "streaming child closed after the
+			// loop ended" rendezvous: the producer doesn't care whether the
+			// run is alive or asleep, just that the prompt reaches it.
+			wake: createEvent("run.wake"),
 		},
 		loop: {
 			started: createEvent("loop.started"),
@@ -55,8 +63,26 @@ export default function createHooks(debug = false) {
 		},
 		turn: {
 			started: createEvent("turn.started"),
+			// Pre-LLM packet shaping. Filter chain: subscribers receive
+			// `{ messages, rows, contextSize, lastPromptTokens,
+			// assembledTokens, ok, overflow }` and return a transformed
+			// packet. Budget plugin participates here to enforce ceilings
+			// (may demote, may set ok=false on overflow). Other plugins
+			// could trim, re-order, or annotate — same surface.
+			beforeDispatch: createFilter("turn.beforeDispatch"),
 			response: createEvent("turn.response"),
+			// Post-dispatch event. Fired after the per-entry dispatch
+			// loop, before turn.completed. Budget subscribes here for
+			// post-dispatch demotion / 413 overflow detection.
+			dispatched: createEvent("turn.dispatched"),
 			completed: createEvent("turn.completed"),
+			// Verdict filter chain: each subscriber receives the current
+			// verdict object and returns a (possibly modified) one.
+			// Initial value is { continue: true }; final value drives the
+			// loop's continue/abandon decision. Multi-plugin: strike streak,
+			// cycle detect, stagnation pressure, future voters all
+			// participate via this surface.
+			verdict: createFilter("turn.verdict"),
 		},
 		// SPEC #resolution covers the proposal hook chain.
 		proposal: {

package/src/hooks/RummyContext.js

@@ -13,6 +13,7 @@ const CONTEXT_DEFAULTS = Object.freeze({
 	systemPrompt: "",
 	loopPrompt: "",
 	writer: "model",
+	signal: null,
 });
 
 export default class RummyContext {
@@ -122,6 +123,16 @@ export default class RummyContext {
 		return this.#context.writer;
 	}
 
+	// AbortSignal tied to the current run/loop's controller. Plugins that
+	// spawn subprocesses or perform long-running work MUST honor this so
+	// drain (rummy-cli's 895s watchdog → projectAgent.shutdown) can flush
+	// telemetry before harbor's outer SIGKILL. Without this wired into a
+	// spawn, the in-flight subprocess outlives drain and rummy.db / turns/
+	// / last_run.txt never make it out of the docker sandbox.
+	get signal() {
+		return this.#context.signal;
+	}
+
 	get system() {
 		return this.#root.children.find((c) => c.tag === "system");
 	}
@@ -153,7 +164,7 @@ export default class RummyContext {
 				this.runId,
 				"known",
 				body,
-				attributes?.summary,
+				attributes?.tags,
 			);
 		}
 		await this.entries.set({

package/src/lib/hedberg/README.md

@@ -0,0 +1,60 @@
+# hedberg {#hedberg_plugin}
+
+The interpretation boundary between stochastic model output and
+deterministic system operations.
+
+Pattern matching (`hedmatch`, `hedsearch`) auto-detects glob, regex
+(via `/pattern/flags`), jsonpath, xpath, or literal. `Hedberg.replace`
+does fuzzy literal substitution — exact substring first, falling
+through to heuristic whitespace-tolerant matching when the literal
+miss is plausibly indentation drift. Edit-shape parsing
+(`<<IDENT...IDENT` markers in `<set>` bodies) lives in
+`marker.js` and is invoked by the XmlParser at `<set>` resolution
+time; see SPEC.md "Edit Syntax".
+
+## Usage
+
+Any plugin can access hedberg via `core.hooks.hedberg`:
+
+```js
+constructor(core) {
+    const { match, search, replace, generatePatch } = core.hooks.hedberg;
+}
+```
+
+## API (available on core.hooks.hedberg)
+
+| Method | Purpose |
+|---|---|
+| `match(pattern, string)` | Full-string pattern match (glob, regex, literal) |
+| `search(pattern, string)` | Substring search, returns `{ found, match, index }` |
+| `replace(body, search, replacement)` | Fuzzy literal replacement (whitespace-tolerant) |
+| `generatePatch(path, old, new)` | Generate unified diff |
+
+### Hedberg.replace(body, search, replacement)
+
+Apply a replacement to text. Exact substring substitution via
+`String.replaceAll` first; if no literal match, falls through to
+heuristic fuzzy matching that's tolerant of whitespace and
+indentation drift.
+
+```js
+const result = Hedberg.replace(fileContent, "port = 3000", "port = 8080");
+// result: { patch, searchText, replaceText, warning, error }
+```
+
+For regex matching, use the explicit `/pattern/flags` syntax via
+`hedmatch` / `hedsearch`.
+
+## Files
+
+- **hedberg.js** — plugin class, `replace()` method
+- **marker.js** — edit-syntax marker parser (`<<IDENT...IDENT`)
+- **patterns.js** — pattern type detection (regex, glob, jsonpath, xpath, literal)
+- **matcher.js** — heuristic fuzzy matching, diff generation
+
+## Future
+
+This will become a separate npm package (`@possumtech/rummy.hedberg`)
+to isolate the stochastic interpretation logic from the deterministic
+core service.

package/src/lib/hedberg/hedberg.js

@@ -0,0 +1,60 @@
+import HeuristicMatcher, { generatePatch } from "./matcher.js";
+import { hedmatch, hedsearch } from "./patterns.js";
+
+// Stochastic→deterministic boundary; exposes pattern utilities on
+// core.hedberg. SPEC #hedberg. Edit-shape parsing lives in marker.js
+// and is invoked from XmlParser at <set> resolution time.
+export default class Hedberg {
+	#core;
+
+	constructor(core) {
+		this.#core = core;
+
+		core.hooks.hedberg = {
+			match: hedmatch,
+			search: hedsearch,
+			replace: Hedberg.replace,
+			generatePatch,
+		};
+	}
+
+	// Order: literal substitution → heuristic fuzzy.
+	//
+	// sed=true semantically means "literal substring substitution with
+	// regex-style escape friendliness." The model writes `\[`, `\.`,
+	// `\|`, etc. out of muscle memory from real sed, but we don't
+	// compile a regex — native String.replaceAll does the substitution.
+	// We strip the regex-meta backslashes from search and replacement
+	// so the model's escaped chars match their literal counterparts in
+	// body. This sidesteps a class of "regex-meta in content" failures
+	// and the parser-edge-case surface that compiling user input as
+	// regex drags in.
+	static replace(body, search, replacement, { sed = false } = {}) {
+		let patch = null;
+		let warning = null;
+		let error = null;
+		const stripRegexEscapes = (s) => s.replace(/\\([[\](){}.*+?^$|\\])/g, "$1");
+		const searchText = sed ? stripRegexEscapes(search) : search;
+		const replaceText = sed ? stripRegexEscapes(replacement) : replacement;
+
+		if (body.includes(searchText)) {
+			patch = body.replaceAll(searchText, replaceText);
+		}
+
+		if (!patch) {
+			const matched = HeuristicMatcher.matchAndPatch(
+				"",
+				body,
+				searchText,
+				replaceText,
+			);
+			patch = matched.newContent;
+			warning = matched.warning;
+			error = matched.error;
+		}
+
+		return { patch, searchText, replaceText, warning, error };
+	}
+}
+
+export { generatePatch };

package/src/lib/hedberg/marker.js

@@ -0,0 +1,158 @@
+// Edit-syntax marker parser. Recognizes bash-heredoc-shaped
+// `<<IDENT...IDENT` body markers inside `<set>` content and routes
+// by IDENT prefix to one of six operations: NEW, PREPEND, APPEND,
+// REPLACE, DELETE, SEARCH. Non-keyword IDENTs (e.g. `<<DOC`, `<<EOF`)
+// route to REPLACE — the content between markers becomes the full
+// new body.
+//
+// Grammar:
+//   - Opener: `<<IDENT` where IDENT matches `[A-Z][A-Za-z0-9_]*`.
+//     Boundary: preceded by start-of-body, whitespace, or `>` (so
+//     `vec<<SEARCH` mid-token does not false-trigger).
+//   - Closer: bare IDENT (matching opener exactly) with non-word
+//     boundaries — preceded by whitespace/start, followed by
+//     whitespace, `<`, `>`, or end.
+//   - SEARCH must be immediately followed by REPLACE; the pair maps
+//     to one search_replace op. Lone SEARCH is a parse error.
+//   - Trailing alphanumeric suffix on the IDENT is opaque to routing
+//     (`<<SEARCH1` and `<<SEARCH` both route to SEARCH). Suffix
+//     exists so nested markers can disambiguate, same convention as
+//     bash heredoc `<<EOF1` vs `<<EOF`. When a body literally
+//     contains the bare keyword (`SEARCH` in prose or code), the
+//     model picks a suffix so the inner literal does not prematurely
+//     close the outer marker.
+//
+// The bare `<<IDENT` shape is visibly distinct from the engine's
+// packet-rendering shape `<<:::IDENT` (see plugins/helpers.js). Edit
+// syntax is bare-only: a body with `<<:::IDENT` does NOT match this
+// parser and falls through to plain-body REPLACE with the markers
+// preserved as literal content. Keep the two grammars distinct so
+// model emissions and engine renderings can never be confused.
+//
+// Returns:
+//   { ops: null,    error: null }   — no markers found, treat body as plain.
+//   { ops: [{...}], error: null }   — well-formed marker(s).
+//   { ops: null,    error: "..." }  — parse failure (lone SEARCH, unclosed).
+
+const KEYWORD_RE =
+	/^(NEW|PREPEND|APPEND|REPLACE|DELETE|SEARCH)([A-Za-z0-9_]*)$/;
+
+// Opener: `<<IDENT` preceded by start-of-input, whitespace, or `>`.
+const OPENER_RE = /(?<=^|[\s>])<<([A-Z][A-Za-z0-9_]*)/;
+
+function operationFromIdent(ident) {
+	const m = ident.match(KEYWORD_RE);
+	if (m) return m[1].toLowerCase();
+	// Non-keyword IDENT — treat as REPLACE.
+	return "replace";
+}
+
+function findOpener(body, startIdx) {
+	const slice = body.slice(startIdx);
+	const match = slice.match(OPENER_RE);
+	if (!match) return null;
+	return {
+		ident: match[1],
+		openerStart: startIdx + match.index,
+		openerEnd: startIdx + match.index + match[0].length,
+	};
+}
+
+function findCloser(body, startIdx, ident) {
+	const escIdent = ident.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	// Closer: bare IDENT with non-word boundaries — preceded by
+	// whitespace or start-of-input, followed by whitespace, `<`, `>`,
+	// or end. The trailing `<` lets the SEARCH closer adjoin an
+	// immediately-following `<<REPLACE` opener (`SEARCH<<REPLACE`).
+	const re = new RegExp(`(?<=^|\\s)${escIdent}(?=[\\s<>]|$)`);
+	const slice = body.slice(startIdx);
+	const match = slice.match(re);
+	if (!match) return null;
+	return {
+		closerStart: startIdx + match.index,
+		closerEnd: startIdx + match.index + match[0].length,
+	};
+}
+
+function trimMarkerNewlines(content) {
+	let result = content;
+	if (result.startsWith("\n")) result = result.slice(1);
+	if (result.endsWith("\n")) result = result.slice(0, -1);
+	return result;
+}
+
+// Detect a body that is exactly one heredoc wrapping its entire content.
+// Returns `{ ident, content }` if `body` is `<<IDENT\n...\nIDENT` (with
+// optional surrounding whitespace), otherwise `null`. Used by non-`<set>`
+// plugins to let models opaquely wrap multi-line scripts, tag-shaped
+// prose, or content with special characters — without requiring escaping
+// or string-quoting at the model layer. The plugin sees the unwrapped
+// inner content as its body; the IDENT is attached to the command as
+// `heredocIdent` for plugins that want to act on the label.
+//
+// Reuses the same `findOpener`/`findCloser` helpers as `parseMarkerBody`,
+// so the grammar (boundary rules, IDENT shape, suffix nesting) stays
+// single-sourced. Difference is just the validation: this function
+// requires the heredoc to span the body exactly (opener at start,
+// closer at end), where `parseMarkerBody` accepts multiple markers in
+// sequence.
+export function extractSingleHeredoc(body) {
+	if (!body) return null;
+	const trimmed = body.trim();
+	if (!trimmed.startsWith("<<")) return null;
+
+	const opener = findOpener(trimmed, 0);
+	if (!opener || opener.openerStart !== 0) return null;
+
+	const closer = findCloser(trimmed, opener.openerEnd, opener.ident);
+	if (!closer || closer.closerEnd !== trimmed.length) return null;
+
+	const content = trimMarkerNewlines(
+		trimmed.slice(opener.openerEnd, closer.closerStart),
+	);
+	return { ident: opener.ident, content };
+}
+
+export function parseMarkerBody(body) {
+	// Cheap rejection — most `<set>` bodies don't contain markers.
+	if (!/<<[A-Z]/.test(body)) return { ops: null, error: null };
+
+	const raw = [];
+	let i = 0;
+	while (i < body.length) {
+		const opener = findOpener(body, i);
+		if (!opener) break;
+		const op = operationFromIdent(opener.ident);
+		const closer = findCloser(body, opener.openerEnd, opener.ident);
+		if (!closer) {
+			return { ops: null, error: `unclosed <<${opener.ident}` };
+		}
+		const content = trimMarkerNewlines(
+			body.slice(opener.openerEnd, closer.closerStart),
+		);
+		raw.push({ op, content });
+		i = closer.closerEnd;
+	}
+	if (raw.length === 0) return { ops: null, error: null };
+
+	// Pair adjacent SEARCH+REPLACE into one search_replace op.
+	const ops = [];
+	for (let j = 0; j < raw.length; j++) {
+		const cur = raw[j];
+		if (cur.op === "search") {
+			const next = raw[j + 1];
+			if (!next || next.op !== "replace") {
+				return { ops: null, error: "lone SEARCH (no REPLACE)" };
+			}
+			ops.push({
+				op: "search_replace",
+				search: cur.content,
+				replace: next.content,
+			});
+			j++;
+		} else {
+			ops.push(cur);
+		}
+	}
+	return { ops, error: null };
+}

package/src/{plugins → lib}/hedberg/matcher.js

@@ -99,8 +99,7 @@ export default class HeuristicMatcher {
 			return {
 				patch: null,
 				warning: null,
-				error:
-					"SEARCH blocks are matched literally, not as a pattern. Could not find the SEARCH block in the file.",
+				error: "SEARCH text not found in current body.",
 			};
 		}
 

package/src/llm/LlmProvider.js

@@ -1,4 +1,3 @@
-import config from "../agent/config.js";
 import msg from "../agent/messages.js";
 import {
 	ContextExceededError,
@@ -7,7 +6,19 @@ import {
 } from "./errors.js";
 import { retryClassified } from "./retry.js";
 
-const { LLM_DEADLINE, LLM_MAX_BACKOFF } = config;
+const LLM_DEADLINE = Number(process.env.RUMMY_LLM_DEADLINE);
+const LLM_MAX_BACKOFF = Number(process.env.RUMMY_LLM_MAX_BACKOFF);
+
+const TOKEN_DIVISOR = Number(process.env.RUMMY_TOKEN_DIVISOR);
+// Floor on derived max_tokens. If prompt eats almost the entire context,
+// we still ask for at least this many output tokens so the model has
+// room to emit a usable terminal `<update>`.
+const MAX_TOKENS_FLOOR = 1024;
+// Fraction of the model's context the request may consume (prompt +
+// max_tokens combined). The remaining 1−X absorbs tokenizer drift
+// between our chars/RUMMY_TOKEN_DIVISOR estimate and the provider's
+// BPE-based count plus message-envelope overhead.
+const BUDGET_CEILING = Number(process.env.RUMMY_BUDGET_CEILING);
 
 // Per-category retry policies. Gateway/server are bounded short because
 // upstream-down won't recover by waiting; warmup/rate_limit get the full
@@ -55,7 +66,34 @@ export default class LlmProvider {
 			(process.env.RUMMY_TEMPERATURE !== undefined
 				? Number.parseFloat(process.env.RUMMY_TEMPERATURE)
 				: undefined);
-		const resolvedOptions = { ...options, temperature };
+
+		// Derive max_tokens from the model's context window minus the
+		// estimated prompt footprint. Without this, providers fall back
+		// to conservative defaults (a few thousand) and the model's
+		// response truncates mid-`<set>` body before reaching `<update>`,
+		// surfacing as a misleading "no <update>" verdict.
+		const contextLength = await this.getContextSize(model);
+		const promptEstimate = messages.reduce(
+			(sum, m) => sum + Math.ceil(m.content.length / TOKEN_DIVISOR),
+			0,
+		);
+		const effectiveContext = Math.floor(contextLength * BUDGET_CEILING);
+		let maxTokens = Math.max(
+			MAX_TOKENS_FLOOR,
+			effectiveContext - promptEstimate,
+		);
+		// Per-model output ceiling. Models advertise huge context windows
+		// but actual max OUTPUT tokens is far smaller. Sending max_tokens
+		// above the model's real output cap pushes the request into
+		// undefined-behavior territory and can correlate with mid-emission
+		// EOT sampling. Set `RUMMY_OUTPUT_CAP_<alias>` per model where
+		// the published output ceiling is known.
+		const outputCapEnv = process.env[`RUMMY_OUTPUT_CAP_${model}`];
+		if (outputCapEnv) {
+			const cap = Number.parseInt(outputCapEnv, 10);
+			if (cap > 0) maxTokens = Math.min(maxTokens, cap);
+		}
+		const resolvedOptions = { ...options, temperature, maxTokens };
 
 		const provider = this.#selectProvider(resolvedModel);
 		if (!provider) {

package/src/llm/openaiStream.js

@@ -62,6 +62,12 @@ 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).
+	const chunkMetadata = {};
 
 	while (true) {
 		const { done, value } = await reader.read();
@@ -90,6 +96,16 @@ 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;
+			}
+
 			const choice = chunk.choices?.[0];
 			if (!choice) continue;
 			if (choice.finish_reason) finishReason = choice.finish_reason;
@@ -121,5 +137,6 @@ export async function chatCompletionStream({ url, headers, body, signal }) {
 			},
 		],
 		usage,
+		chunkMetadata,
 	};
 }