@possumtech/rummy 2.0.1 → 2.2.0

package/src/plugins/stream/finalize.js

@@ -0,0 +1,100 @@
+import Entries from "../../agent/Entries.js";
+import { logPathToDataBase } from "../helpers.js";
+
+// Single termination site for streaming entries. Both stream/completed
+// (external producer signaling close) and yolo's local child-spawn
+// close handler funnel through here so finalization shape stays
+// identical: channel terminal states, log-entry body rewrite, and
+// dormant-run wake all live in one place.
+//
+// terminalState: "resolved" (exit_code=0), "failed" (non-zero).
+// Aborts/cancellations write their own state ("cancelled") through the
+// stream/aborted and stream/cancel paths and do NOT call this helper —
+// explicit cancellation should not summon a follow-up turn.
+export default async function finalizeStream({
+	db,
+	entries,
+	hooks,
+	runRow,
+	path,
+	exitCode = 0,
+	duration = null,
+	wake = true,
+}) {
+	const rawBase = logPathToDataBase(path);
+	if (!rawBase) {
+		throw new Error(
+			`path must be a log entry (log://turn_N/...); got: ${path}`,
+		);
+	}
+	// The log entry path may arrive in its raw URL-encoded form (e.g.
+	// `%20` for spaces) but the data-channel rows are stored under the
+	// canonical form (`%20` → `_` via encodeSegment). Normalize the
+	// derived dataBase so `${dataBase}_*` matches the stored channel
+	// paths regardless of which form the caller passed in.
+	const dataBase = Entries.normalizePath(rawBase);
+	// Pin every state-transition write to the action's originating turn.
+	// Without this, entries.set's default turn=0 re-stamps the entry's
+	// run_view.turn to 0 — and the auto-failure hook then derives
+	// log://turn_0/error/... for failures that actually happened on
+	// turn N.
+	const turnMatch = path.match(/^log:\/\/turn_(\d+)\//);
+	const turn = turnMatch ? Number(turnMatch[1]) : 0;
+
+	const runId = runRow.id;
+	const terminalState = exitCode === 0 ? "resolved" : "failed";
+	const terminalOutcome = exitCode === 0 ? null : `exit:${exitCode}`;
+
+	const channels = await entries.getEntriesByPattern(
+		runId,
+		`${dataBase}_*`,
+		null,
+	);
+	for (const ch of channels) {
+		await entries.set({
+			runId,
+			turn,
+			path: ch.path,
+			state: terminalState,
+			body: ch.body,
+			outcome: terminalOutcome,
+		});
+	}
+
+	const logEntry = await entries.getAttributes(runId, path);
+	let command = "";
+	if (logEntry?.command) command = logEntry.command;
+	else if (logEntry?.summary) command = logEntry.summary;
+	const channelSummary = channels
+		.map((c) => {
+			const size = c.body ? `${c.tokens} tokens` : "empty";
+			return `${c.path} (${size})`;
+		})
+		.join(", ");
+	const dur = duration ? ` (${duration})` : "";
+	const exitLabel = exitCode === 0 ? "exit=0" : `exit=${exitCode}`;
+	const body = `ran '${command}', ${exitLabel}${dur}. Output: ${channelSummary}`;
+	await entries.set({ runId, turn, path, state: "resolved", body });
+
+	if (!wake) return { channels: channels.length };
+
+	// Dormancy: any pending (100) or active (102) loop on the run blocks
+	// the wake — the active loop will see the new log entry on its next
+	// turn assembly and the producer doesn't owe it a fresh prompt.
+	const inflight = await db.get_pending_loops.all({ run_id: runId });
+	if (inflight.length > 0) return { channels: channels.length, woke: false };
+
+	// Mode for the wake loop: inherit from the latest completed loop on
+	// the run. Fresh runs without a completed loop don't get woken (the
+	// child closing before any loop terminated is a state we'd never
+	// reach in practice).
+	const latest = await db.get_latest_completed_loop.get({ run_id: runId });
+	if (!latest) return { channels: channels.length, woke: false };
+
+	await hooks.run.wake.emit({
+		runAlias: runRow.alias,
+		body: "Process complete",
+		mode: latest.mode,
+	});
+	return { channels: channels.length, woke: true };
+}

package/src/plugins/stream/stream.js

@@ -1,22 +1,7 @@
 import { logPathToDataBase } from "../helpers.js";
+import finalizeStream from "./finalize.js";
 
-/**
- * Stream plugin — generic streaming entry infrastructure.
- *
- * Receives chunks from the client (or any producer) and appends them to
- * existing data entries. Producers (sh/env handlers) create the data
- * entries at status=102 on proposal acceptance; this plugin handles the
- * subsequent append + terminal-status transition via two RPC methods.
- *
- * RPC `path` param is the **log-entry path** (log://turn_N/{action}/{slug}
- * — that's what the client sees on `run/proposal`). Channels live under
- * the producer scheme ({action}://turn_N/{slug}_N) for a clean
- * data-vs-logging namespace split; this plugin derives the data base from
- * the log path on every RPC call.
- *
- * Not a model-facing tool. No scheme, no tooldoc, no dispatch handler.
- * Pure RPC plumbing that any streaming-producer plugin can leverage.
- */
+// RPC plumbing that appends/terminates streaming data entries; see plugin README.
 export default class Stream {
 	#core;
 
@@ -25,9 +10,7 @@ export default class Stream {
 		const hooks = core.hooks;
 		const r = hooks.rpc.registry;
 
-		// stream: append a chunk to a streaming entry.
-		// Entry path is constructed as `${path}_${channel}` per the Unix FD
-		// convention (1=stdout, 2=stderr, higher=other producer channels).
+		// stream: append chunk; channel = Unix FD (1=stdout, 2=stderr).
 		r.register("stream", {
 			handler: async (params, ctx) => {
 				if (!params.run) throw new Error("run is required");
@@ -67,8 +50,7 @@ export default class Stream {
 			requiresInit: true,
 		});
 
-		// stream/completed: transition all data channels for this producer
-		// to their terminal status and finalize the log entry body.
+		// stream/completed: terminal status on all channels + finalize log body.
 		r.register("stream/completed", {
 			handler: async (params, ctx) => {
 				if (!params.run) throw new Error("run is required");
@@ -78,56 +60,22 @@ export default class Stream {
 					alias: params.run,
 				});
 				if (!runRow) throw new Error(`run not found: ${params.run}`);
-				const runId = runRow.id;
 
 				const { exit_code: exitCode = 0, duration = null } = params;
-				const terminalState = exitCode === 0 ? "resolved" : "failed";
-				const terminalOutcome = exitCode === 0 ? null : `exit:${exitCode}`;
-
-				const dataBase = logPathToDataBase(params.path);
-				if (!dataBase) {
-					throw new Error(
-						`path must be a log entry (log://turn_N/...); got: ${params.path}`,
-					);
-				}
-				// Find all `{dataBase}_*` data entries (channels 1, 2, ...).
-				const store = ctx.projectAgent.entries;
-				const channels = await store.getEntriesByPattern(
-					runId,
-					`${dataBase}_*`,
-					null,
-				);
-				for (const ch of channels) {
-					await store.set({
-						runId,
-						path: ch.path,
-						state: terminalState,
-						body: ch.body,
-						outcome: terminalOutcome,
-					});
-				}
-
-				// Update the log entry body with final stats. Keep it terse —
-				// one line summarizing exit code, duration, and channel sizes.
-				const logEntry = await store.getAttributes(runId, params.path);
-				let command = "";
-				if (logEntry?.command) command = logEntry.command;
-				else if (logEntry?.summary) command = logEntry.summary;
-				const channelSummary = channels
-					.map((c) => {
-						const size = c.body ? `${c.tokens} tokens` : "empty";
-						return `${c.path} (${size})`;
-					})
-					.join(", ");
-				const dur = duration ? ` (${duration})` : "";
-				const exitLabel = exitCode === 0 ? "exit=0" : `exit=${exitCode}`;
-				const body = `ran '${command}', ${exitLabel}${dur}. Output: ${channelSummary}`;
-				await store.set({ runId, path: params.path, state: "resolved", body });
-
-				return { ok: true, channels: channels.length };
+				const result = await finalizeStream({
+					db: ctx.db,
+					entries: ctx.projectAgent.entries,
+					hooks,
+					runRow,
+					path: params.path,
+					exitCode,
+					duration,
+					wake: true,
+				});
+				return { ok: true, ...result };
 			},
 			description:
-				"Finalize a streaming producer. Transitions all `{path}_*` data channels to terminal status (200 on exit_code=0, 500 otherwise) and rewrites the log entry body with exit code, duration, and channel sizes.",
+				"Finalize a streaming producer. Transitions all `{path}_*` data channels to terminal status (200 on exit_code=0, 500 otherwise), rewrites the log entry body with exit code/duration/channel sizes, and wakes the run with a 'Process complete' prompt if it has gone dormant.",
 			params: {
 				run: "string — run alias",
 				path: "string — log-entry path (log://turn_N/{action}/{slug}); server derives the data channel path",
@@ -138,11 +86,7 @@ export default class Stream {
 			requiresInit: true,
 		});
 
-		// stream/aborted: client-initiated cancellation. Transitions all data
-		// channels to status 499 (Client Closed Request — the de-facto HTTP
-		// status for client-terminated requests) and rewrites the log entry
-		// body to note the abort. Shape mirrors stream/completed for client
-		// symmetry: same run/path addressing, same channel sweep.
+		// stream/aborted: client cancellation; channels → 499; mirrors stream/completed.
 		r.register("stream/aborted", {
 			handler: async (params, ctx) => {
 				if (!params.run) throw new Error("run is required");
@@ -211,12 +155,7 @@ export default class Stream {
 			requiresInit: true,
 		});
 
-		// stream/cancel: server-initiated cancellation. Any client (or
-		// internal server code) can cancel a streaming producer — the server
-		// transitions channels to 499 immediately and pushes a
-		// stream/cancelled notification so connected clients can kill their
-		// local processes. Also serves as stale 102 cleanup: if the client
-		// died mid-stream, call stream/cancel to mark orphaned entries terminal.
+		// stream/cancel: server-initiated; pushes stream/cancelled notification; cleans stale 102s.
 		r.register("stream/cancel", {
 			handler: async (params, ctx) => {
 				if (!params.run) throw new Error("run is required");

package/src/plugins/telemetry/telemetry.js

@@ -1,12 +1,16 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
+// model://N is a diagnostic slice; full content is in assistant://N.
+const MODEL_SNAPSHOT_BYTES = 4096;
+
 export default class Telemetry {
 	#core;
 	#starts = new Map();
 	#lastRunPath = null;
 	#turnsDir = null;
 	#turnLog = [];
+	#turnStartIdx = 0;
 	#currentRunAlias = null;
 	#currentTurn = null;
 
@@ -31,8 +35,8 @@ export default class Telemetry {
 	async #onRpcStarted({ method, id, params }) {
 		this.#starts.set(id, Date.now());
 		let summary = "";
-		if (method === "ask" || method === "act") {
-			const prompt = params?.prompt ? params.prompt : "";
+		if (method === "set" && params?.path?.startsWith("run://")) {
+			const prompt = params?.body ? params.body : "";
 			summary = `prompt="${prompt.slice(0, 60)}"`;
 		} else if (method === "run/abort") {
 			summary = `run=${params?.run}`;
@@ -40,10 +44,6 @@ export default class Telemetry {
 			summary = `run=${params?.run} action=${params?.resolution?.action}`;
 		}
 		console.log(`[RPC] → ${method}(${id})${summary ? ` ${summary}` : ""}`);
-
-		if (method === "ask" || method === "act") {
-			this.#turnLog = [];
-		}
 	}
 
 	async #onRpcCompleted({ method, id, result }) {
@@ -136,7 +136,7 @@ export default class Telemetry {
 				reasoning_content: responseMessage?.reasoning_content
 					? responseMessage.reasoning_content
 					: null,
-				content: content.slice(0, 4096),
+				content: content.slice(0, MODEL_SNAPSHOT_BYTES),
 				usage: result.usage ? result.usage : null,
 				model: result.model ? result.model : null,
 			}),
@@ -161,10 +161,7 @@ export default class Telemetry {
 			}
 		}
 
-		// content://N — unparsed text. 400 Bad Request because anything in
-		// unparsed is text the parser couldn't dispatch (malformed XML, native
-		// tool call attempts, reasoning bleed). Visible to the model so it
-		// sees the rejection on its next turn and can correct.
+		// content://N — visible-rejected unparsed text so the model can correct next turn.
 		if (unparsed) {
 			await store.set({
 				runId,
@@ -179,9 +176,7 @@ export default class Telemetry {
 			});
 		}
 
-		// Commit usage stats. Providers surface token counts under
-		// incompatible keys; walk them in priority order and fall back
-		// to 0 only as the definitional "not reported" value.
+		// Per-provider key drift; walk in priority order, 0 = not reported.
 		const usage = result.usage ? result.usage : {};
 		const cachedSources = [
 			usage.cached_tokens,
@@ -206,12 +201,23 @@ export default class Telemetry {
 				reasoningTokens = v;
 				break;
 			}
-		// Use LLM's actual prompt_tokens as the ground-truth context size
-		// when available; falls back to our pre-call estimate.
+		// LLM's prompt_tokens is ground truth; estimator is pre-call fallback.
 		let actualContextTokens = 0;
 		if (usage.prompt_tokens) actualContextTokens = usage.prompt_tokens;
 		else if (assembledTokens) actualContextTokens = assembledTokens;
 		const numberOrZero = (v) => (typeof v === "number" ? v : 0);
+		// Forensic metadata blob — everything the provider sent that
+		// isn't content/reasoning_content (those live elsewhere) or
+		// already-derived columns (token counts, cost). Catches
+		// finish_reason, system_fingerprint, response id, service_tier,
+		// raw usage, and any provider-specific fields that may light up
+		// future investigations. JSON column tolerates shape drift.
+		const responseMetadata = {
+			finish_reason: result.choices[0].finish_reason,
+			model_returned: result.model,
+			usage: result.usage,
+			...result.chunkMetadata,
+		};
 		await rummy.entries.updateTurnStats({
 			id: rummy.turnId,
 			context_tokens: actualContextTokens,
@@ -223,15 +229,38 @@ export default class Telemetry {
 			completion_tokens: numberOrZero(usage.completion_tokens),
 			reasoning_tokens: reasoningTokens,
 			total_tokens: numberOrZero(usage.total_tokens),
-			cost: numberOrZero(usage.cost),
+			// Cost surfaces under different field names by provider:
+			// - OpenRouter direct: `usage.cost` (USD, what the relay billed us)
+			// - OpenRouter BYOK: `usage.cost.upstream_inference_cost` (USD,
+			//   relay didn't bill — upstream charged our key directly, so
+			//   `usage.cost` is 0 and the true compute cost lives here).
+			// - xAI direct: `usage.cost_in_usd_ticks` where 1 tick = 10⁻¹⁰
+			//   USD (verified empirically: 11 uncached + 161 cached + 1
+			//   output tokens → 107,500 ticks → $0.00001075 at xAI's
+			//   $0.20/M input, $0.05/M cached, $0.50/M output rates).
+			//   Divide by 1e10 to land in USD alongside the others.
+			// All three normalized to USD; downstream summaries sum them
+			// as comparable dollars.
+			cost:
+				numberOrZero(usage.cost) ||
+				numberOrZero(usage.cost_details?.upstream_inference_cost) ||
+				numberOrZero(usage.cost_in_usd_ticks) / 1e10,
+			response_metadata: JSON.stringify(responseMetadata),
 		});
 	}
 
 	async #logMessages(messages, context) {
-		this.#currentRunAlias = context.runAlias
+		const newAlias = context.runAlias
 			? context.runAlias
 			: `run_${context.runId}`;
+		// Reset on alias change (the semantic run boundary).
+		if (newAlias !== this.#currentRunAlias) {
+			this.#turnLog = [];
+		}
+		this.#currentRunAlias = newAlias;
 		this.#currentTurn = context.turn === undefined ? null : context.turn;
+		// Per-turn slice index; turn_NNN.txt = this turn only, last_run.txt = cumulative.
+		this.#turnStartIdx = this.#turnLog.length;
 		const turnLabel = this.#currentTurn === null ? "?" : this.#currentTurn;
 		this.#turnLog.push(
 			`\n${"=".repeat(60)}\nTURN ${turnLabel} — model=${context.model} run=${this.#currentRunAlias}\n${"=".repeat(60)}`,
@@ -272,6 +301,7 @@ export default class Telemetry {
 		const runDir = join(this.#turnsDir, this.#currentRunAlias);
 		await mkdir(runDir, { recursive: true });
 		const fileName = `turn_${String(this.#currentTurn).padStart(3, "0")}.txt`;
-		await writeFile(join(runDir, fileName), `${this.#turnLog.join("\n")}\n`);
+		const turnSlice = this.#turnLog.slice(this.#turnStartIdx);
+		await writeFile(join(runDir, fileName), `${turnSlice.join("\n")}\n`);
 	}
 }

package/src/plugins/think/think.js

@@ -1,13 +1,11 @@
 import docs from "./thinkDoc.js";
 
-const THINK_ENABLED = process.env.RUMMY_THINK;
-if (THINK_ENABLED === undefined)
-	throw new Error("RUMMY_THINK must be set (1 or 0)");
+const THINK = process.env.RUMMY_THINK === "1";
 
 export default class Think {
 	constructor(core) {
 		core.registerScheme({ modelVisible: 0, category: "logging" });
-		if (THINK_ENABLED === "1") {
+		if (THINK) {
 			core.ensureTool();
 			core.filter("instructions.toolDocs", async (docsMap) => {
 				docsMap.think = docs;
@@ -15,9 +13,7 @@ export default class Think {
 			});
 		}
 
-		// Merge <think> tag bodies into the turn's reasoning_content so
-		// models without a dedicated reasoning channel still expose their
-		// reasoning through the same field.
+		// Merge <think> bodies into reasoning_content for models without a reasoning channel.
 		core.filter("llm.reasoning", (reasoning, { commands }) => {
 			const thinkText = commands
 				.filter((c) => c.name === "think")

package/src/plugins/think/thinkDoc.md

@@ -1,7 +1,5 @@
 ## <think>[reasoning]</think> - Think before acting
 
-* Use <think></think> before any other tools to plan your approach
-<!-- Positioning: think first, then act. Prevents degenerate tool-call storms. -->
+Example: <think>Plan: <search> for X; <get> the top-ranked result; distill into known://Y.</think>
 
-* Reasoning inside <think></think> is private — it does not appear in your context
-<!-- Frees the model to reason without consuming context budget. -->
+* Reasoning inside <think></think> is private — it does not appear in your context.

package/src/plugins/unknown/README.md

@@ -9,7 +9,7 @@ The Rumsfeld mechanism. The model registers what it doesn't know before acting.
 - **Tool**: `unknown`
 - **Category**: `unknown`
 - **Handler**: None — recorded by TurnExecutor, deduplicated against existing unknowns.
-- **Filter**: `assembly.user` at priority 200 — renders `<unknowns>` adjacent to `<prompt>` (priority 300), after `<performed>` (priority 100). Unknowns are active work, not stable environment state; they belong in the user packet.
+- **Filter**: `assembly.user` at priority 150 — renders `<unknowns>` after `<log>` (priority 100) and before `<instructions>` (priority 165) in the sandwich. Unknowns are active work, not stable environment state; they belong in the user packet.
 
 ## Projection
 

package/src/plugins/unknown/unknown.js

@@ -1,8 +1,7 @@
-export default class Unknown {
-	#core;
+import { renderEntry, SUMMARY_MAX_CHARS } from "../helpers.js";
 
+export default class Unknown {
 	constructor(core) {
-		this.#core = core;
 		core.ensureTool();
 		core.registerScheme({
 			category: "unknown",
@@ -10,33 +9,36 @@ export default class Unknown {
 		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.assembleUnknowns.bind(this), 200);
+		core.filter("assembly.user", this.assembleUnknowns.bind(this), 175);
+		// Hidden from the advertised tool list — the model writes unknowns
+		// via <set path="unknown://..."/>. The unknown:// scheme lifecycle
+		// is taught in instructions-user.md, not in a separate tooldoc.
 		core.markHidden();
 	}
 
 	async handler(entry, rummy) {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 
-		// Deduplicate — if this exact body already exists, skip
 		const existingValues = await store.getUnknownValues(runId);
 		if (existingValues.has(entry.body)) {
-			await this.#core.hooks.error.log.emit({
-				store,
+			await store.set({
 				runId,
 				turn,
 				loopId,
-				message: `Unknown deduped: "${entry.body.slice(0, 60)}"`,
+				path: entry.resultPath || entry.path,
+				body: `Unknown deduped: "${entry.body.slice(0, 60)}"`,
+				state: "failed",
+				outcome: "duplicate",
 			});
 			return;
 		}
 
-		// Generate slug path and upsert. Summary (if provided) becomes the
-		// path so the model can round-trip it via <get>; body is the fallback.
+		// tags > body for slug; lets the model round-trip via <get>.
 		const unknownPath = await store.slugPath(
 			runId,
 			"unknown",
 			entry.body,
-			entry.attributes?.summary,
+			entry.attributes?.tags,
 		);
 		await store.set({
 			runId,
@@ -52,13 +54,10 @@ export default class Unknown {
 		return entry.body;
 	}
 
-	// Same principle as knowns: keep the first 500 characters on
-	// summarized unknowns so demotion doesn't erase the question,
-	// but cap large bodies to bound the packet cost.
+	// First SUMMARY_MAX_CHARS of the body. Matches <known> / <prompt>.
 	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 question]`;
+		return entry.body.slice(0, SUMMARY_MAX_CHARS);
 	}
 
 	async assembleUnknowns(content, ctx) {
@@ -74,18 +73,12 @@ function renderUnknownTag(entry) {
 		typeof entry.attributes === "string"
 			? JSON.parse(entry.attributes)
 			: entry.attributes;
-	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
-	const visibility = entry.visibility
-		? ` visibility="${entry.visibility}"`
-		: "";
-	const tokens = entry.aTokens != null ? ` tokens="${entry.aTokens}"` : "";
-	const summary =
-		typeof attrs?.summary === "string"
-			? ` summary="${attrs.summary.replace(/"/g, "'").slice(0, 80)}"`
-			: "";
-	const attrStr = `${turn}${summary}${visibility}${tokens}`;
-	if (entry.body) {
-		return `<unknown path="${entry.path}"${attrStr}>${entry.body}</unknown>`;
+	const meta = {};
+	if (entry.source_turn) meta.turn = entry.source_turn;
+	if (typeof attrs?.tags === "string") {
+		meta.tags = attrs.tags.slice(0, 80);
 	}
-	return `<unknown path="${entry.path}"${attrStr}/>`;
+	if (entry.visibility) meta.visibility = entry.visibility;
+	if (entry.aTokens != null) meta.tokens = entry.aTokens;
+	return renderEntry(entry.path, meta, entry.body);
 }

package/src/plugins/update/update.js

@@ -1,16 +1,8 @@
 import docs from "./updateDoc.js";
 
-const TERMINAL_STATUSES = new Set([200, 204, 422, 500]);
-
 const CONTRACT_REMINDER = "Missing update";
 
-const EMPTY_RESPONSE_REMINDER =
-	"Response empty - Update with status 500 if unable to fulfill request.";
-
-function isValidStatus(status) {
-	if (TERMINAL_STATUSES.has(status)) return true;
-	return Number.isInteger(status) && status >= 100 && status < 200;
-}
+const EMPTY_RESPONSE_REMINDER = "Response empty";
 
 export default class Update {
 	#core;
@@ -32,60 +24,22 @@ export default class Update {
 	}
 
 	async handler(entry, rummy) {
-		const status = entry.attributes?.status ?? 102;
-		const validation = await rummy.hooks.instructions.validateNavigation(
-			status,
-			rummy,
-		);
-		const attributes = validation.ok ? {} : { rejected: true };
-		await rummy.update(entry.body, { status, attributes });
-		if (!validation.ok) {
-			await rummy.hooks.error.log.emit({
-				store: rummy.entries,
-				runId: rummy.runId,
-				turn: rummy.sequence,
-				loopId: rummy.loopId,
-				message: validation.reason,
-				status: 422,
-			});
-		}
+		await rummy.update(entry.body, { status: entry.attributes?.status });
 	}
 
-	/**
-	 * Classify this turn's update state.
-	 *
-	 * Returns { summaryText, updateText }:
-	 *   - summaryText: non-null → model claimed terminal (200/204/422)
-	 *   - updateText:  non-null → model is continuing (1xx)
-	 *
-	 * Errors (invalid status, missing update) emit via hooks.error.log.
-	 * The "terminal + turn had errors → not actually terminal" rule
-	 * lives in the error plugin's verdict, not here.
-	 */
 	async resolve({ recorded, content, runId, turn, loopId, rummy }) {
 		const entry = recorded.findLast((e) => e.scheme === "update");
-		const status = entry?.attributes?.status ?? 102;
-		const rejected = entry?.attributes?.rejected === true;
-		const isTerminal = TERMINAL_STATUSES.has(status) && !rejected;
+		const status = entry?.attributes?.status;
+		const failed = entry?.state === "failed";
+		const isTerminal = status === 200 && !failed;
 		let summaryText = null;
 		let updateText = null;
-		if (entry?.body) {
+		if (entry?.body && !failed) {
 			if (isTerminal) summaryText = entry.body;
 			else updateText = entry.body;
 		}
 
-		if (entry && !isValidStatus(status)) {
-			await rummy.hooks.error.log.emit({
-				store: rummy.entries,
-				runId,
-				turn,
-				loopId,
-				message: `Invalid status ${entry.attributes?.status} on update — use 1xx to continue or 200 to conclude.`,
-				status: 422,
-			});
-		}
-
-		if (!summaryText && !updateText) {
+		if (!summaryText && !updateText && !failed) {
 			const empty = !content || content.trim() === "";
 			await rummy.hooks.error.log.emit({
 				store: rummy.entries,

package/src/plugins/update/updateDoc.md

@@ -1,8 +1,23 @@
-## <update status="N">{brief status}</update> - Status report (exactly one per turn, at the end)
-<!-- Header defines position, frequency, and status code requirement. -->
+## <update status="N">{ direct answer or one-line summary }</update> - Turn termination
 
-REQUIRED: the valid values of N are defined by your current stage instructions.
-<!-- Single source of truth for codes is the current phase instructions block, not this doc. Listing codes here leaks termination knowledge (e.g. 200) that strong models use to short-circuit the protocol. -->
+YOU MUST conclude every turn with one (and only one) <update status="N"></update>.
+YOU MUST keep the update body to <= 80 characters.
+YOU MUST use status 102 for continuation and 200 for final delivery.
 
-REQUIRED: YOU MUST keep <update></update> body to <= 80 characters.
-<!-- Length cap. -->
+Example:
+	{ demote irrelevant source entries and log entries }
+	<set path="known://plan"><<SEARCH
+	- [ ] Distill geography unknowns
+	SEARCH
+	<<REPLACE
+	- [x] Distill geography unknowns
+	REPLACE</set>
+	<update status="102">distilled three unknowns into known://trivia/geography/capitals</update>
+Example:
+	<set path="known://plan"><<SEARCH
+	- [ ] Deliver direct answer
+	SEARCH
+	<<REPLACE
+	- [x] Deliver direct answer
+	REPLACE</set>
+	<update status="200">Paris</update>