@possumtech/rummy 2.0.0 → 2.0.1

package/src/llm/retry.js

@@ -0,0 +1,63 @@
+/**
+ * Exponential backoff with full jitter, time-bounded.
+ *
+ * Calls `fn` until it returns a value, the deadline elapses, or a
+ * non-retryable error is thrown. Between attempts, sleeps for a
+ * random duration in [0, min(maxDelayMs, baseDelayMs * 2^attempt)).
+ * Full jitter (AWS / Google Cloud pattern) prevents thundering-herd
+ * synchronization across concurrent clients hitting the same API.
+ *
+ * Time-bounded, not count-bounded: a connect-level outage that
+ * recovers in 4 minutes is invisible to the caller, but a persistent
+ * outage fails after deadlineMs with a clear cause chain.
+ *
+ * Aborts immediately if the supplied AbortSignal fires — even mid-sleep.
+ */
+export async function retryWithBackoff(
+	fn,
+	{
+		signal,
+		deadlineMs,
+		baseDelayMs = 1000,
+		maxDelayMs = 30_000,
+		isRetryable,
+		onRetry,
+	} = {},
+) {
+	const startTime = Date.now();
+	let attempt = 0;
+	while (true) {
+		signal?.throwIfAborted();
+		try {
+			return await fn();
+		} catch (err) {
+			if (!isRetryable(err)) throw err;
+			const elapsedMs = Date.now() - startTime;
+			const remainingMs = deadlineMs - elapsedMs;
+			if (remainingMs <= 0) {
+				throw new Error(
+					`transient failures persisted ${Math.round(elapsedMs / 1000)}s past deadline; last error: ${err.message}`,
+					{ cause: err },
+				);
+			}
+			const expCap = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
+			const jittered = Math.floor(Math.random() * expCap);
+			const delayMs = Math.min(remainingMs, jittered);
+			onRetry?.(err, attempt + 1, delayMs, remainingMs);
+			await sleep(delayMs, signal);
+			attempt++;
+		}
+	}
+}
+
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const t = setTimeout(resolve, ms);
+		if (!signal) return;
+		const onAbort = () => {
+			clearTimeout(t);
+			reject(signal.reason || new Error("aborted"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}

package/src/plugins/budget/budget.js

@@ -66,56 +66,102 @@ export default class Budget {
 
 		const cap = ceiling(contextSize);
 
-		const visibleByScheme = new Map();
+		// Per-scheme aggregation: counts and costs at each visibility tier
+		// plus the savings (premium) the model would unlock by demoting
+		// visible → summarized. All math derives from per-row vTokens
+		// (cost as visible) / sTokens (cost as summarized) / aTokens
+		// (= vTokens − sTokens, the promotion premium).
+		const byScheme = new Map();
 		let visibleCount = 0;
 		let premiumTokens = 0;
 		let summarizedCount = 0;
-		let summarizedTokens = 0;
+		let _summarizedTokens = 0;
 		let floorTokens = 0;
+		let knownVTokens = 0;
+		let sourceVTokens = 0;
+
+		const schemeEntry = (s) => {
+			let e = byScheme.get(s);
+			if (!e) {
+				e = {
+					vis: 0,
+					sum: 0,
+					visTokens: 0, // current cost of visible entries
+					visIfSumTokens: 0, // sTokens of visible (what they'd cost demoted)
+					sumTokens: 0, // current cost of summarized entries
+					premium: 0, // savings from demoting visible → summarized
+				};
+				byScheme.set(s, e);
+			}
+			return e;
+		};
 
 		for (const r of rows) {
 			if (r.aTokens == null) continue;
 			const s = r.scheme || "file";
+			const entry = schemeEntry(s);
 			if (r.visibility === "visible") {
-				const entry = visibleByScheme.get(s) ?? { count: 0, tokens: 0 };
-				entry.count += 1;
-				entry.tokens += r.aTokens;
-				visibleByScheme.set(s, entry);
+				entry.vis += 1;
+				entry.visTokens += r.vTokens || 0;
+				entry.visIfSumTokens += r.sTokens || 0;
+				entry.premium += r.aTokens || 0;
 				visibleCount += 1;
 				premiumTokens += r.aTokens;
 				floorTokens += r.sTokens;
+				const v = r.vTokens || 0;
+				if (s === "known") knownVTokens += v;
+				else if (s === "prompt") sourceVTokens += v;
+				else if (r.category === "data") sourceVTokens += v;
 			} else if (r.visibility === "summarized") {
+				entry.sum += 1;
+				entry.sumTokens += r.sTokens || 0;
 				summarizedCount += 1;
-				summarizedTokens += r.sTokens;
+				_summarizedTokens += r.sTokens;
 				floorTokens += r.sTokens;
 			}
 		}
 
+		const fcrmDenom = knownVTokens + sourceVTokens;
+		const fcrmScore =
+			fcrmDenom > 0 ? (knownVTokens / fcrmDenom).toFixed(2) : "1.00";
+
 		const systemTokens = countTokens(systemPrompt || "");
 		const tokenUsage = floorTokens + premiumTokens + systemTokens;
 		const tokensFree = Math.max(0, cap - tokenUsage);
 
-		const schemeRows = [...visibleByScheme.entries()]
-			.toSorted((a, b) => b[1].tokens - a[1].tokens)
-			.map(([scheme, v]) => {
-				const pct = Math.round((v.tokens / cap) * 100);
-				return `| ${scheme} | ${v.count} | ${v.tokens} | ${pct}% |`;
+		// Sort schemes by current cost descending — biggest-impact rows
+		// land at the top, so "what should I demote first?" reads
+		// straight off the table.
+		const schemeRows = [...byScheme.entries()]
+			.toSorted(
+				([, a], [, b]) =>
+					b.visTokens + b.sumTokens - (a.visTokens + a.sumTokens),
+			)
+			.map(([scheme, e]) => {
+				const cost = e.visTokens + e.sumTokens;
+				const ifAllSum = e.visIfSumTokens + e.sumTokens;
+				return `| ${scheme} | ${e.vis} | ${e.sum} | ${cost} | ${ifAllSum} | ${e.premium} |`;
 			});
 
-		const summarizedPct = Math.round((summarizedTokens / cap) * 100);
-		const systemPct = Math.round((systemTokens / cap) * 100);
+		const systemPct =
+			tokenUsage > 0 ? Math.round((systemTokens / tokenUsage) * 100) : 0;
 
 		const table = [
-			"| scheme | visible | tokens | % |",
-			"|---|---|---|---|",
+			"| scheme | vis | sum | cost | if-all-sum | premium |",
+			"|---|---|---|---|---|---|",
 			...schemeRows,
 		].join("\n");
 
-		const summarizedLine = `Summarized: ${summarizedCount} entries, ${summarizedTokens} tokens (${summarizedPct}% of budget).`;
 		const systemLine = `System: ${systemTokens} tokens (${systemPct}% of budget).`;
 		const totalLine = `Total: ${visibleCount} visible + ${summarizedCount} summarized entries; tokenUsage ${tokenUsage} / ceiling ${cap}. ${tokensFree} tokens free.`;
+		const legend = [
+			"Columns:",
+			"- cost: current cost of this scheme (vTokens for visible + sTokens for summarized)",
+			"- if-all-sum: cost if every entry of this scheme were demoted to summarized",
+			"- premium: savings from demoting visible → summarized (cost − if-all-sum)",
+		].join("\n");
 
-		return `${content}<budget tokenUsage="${tokenUsage}" tokensFree="${tokensFree}">\n${table}\n\n${summarizedLine}\n${systemLine}\n${totalLine}\n</budget>\n`;
+		return `${content}<budget tokenUsage="${tokenUsage}" tokensFree="${tokensFree}" fcrmScore="${fcrmScore}">\n${table}\n\n${legend}\n${systemLine}\n${totalLine}\n</budget>\n`;
 	}
 
 	#check({ contextSize, messages, rows, lastPromptTokens = 0 }) {

package/src/plugins/get/getDoc.md

@@ -1,7 +1,7 @@
-## <get>[path/to/file]</get> - Promote an entry
+## <get path="[path/to/file]"/> - Promote an entry
 
-Example: <get>src/app.js</get>
-<!-- Simplest form. Body = path. -->
+Example: <get path="src/app.js"/>
+<!-- Simplest form. Path attribute. Body is reserved for content filter. -->
 
 Example: <get path="known://*">auth</get>
 <!-- Keyword recall: glob in path, search term in body. -->

package/src/plugins/instructions/instructions.js

@@ -23,7 +23,7 @@ const TURN_FROM_PATH = /^log:\/\/turn_(\d+)\/update\//;
 
 function phaseForStatus(status) {
 	if (status == null) return 4;
-	if (status === 200) return 8;
+	if (status === 200) return 7;
 	const last = status % 10;
 	return PHASES.includes(last) ? last : 4;
 }
@@ -49,6 +49,10 @@ function latestUpdateStatusFromRows(rows) {
 				: r.attributes;
 		const status = attrs?.status;
 		if (status == null) continue;
+		// Rejected updates are written for the model's audit trail but are
+		// not navigation events — phase router skips them so the model
+		// stays in the stage it was already in.
+		if (attrs?.rejected) continue;
 		if (turn > bestTurn || (turn === bestTurn && status > bestStatus)) {
 			bestTurn = turn;
 			bestStatus = status;
@@ -66,6 +70,10 @@ export default class Instructions {
 		core.on("turn.started", this.onTurnStarted.bind(this));
 		core.hooks.instructions.resolveSystemPrompt =
 			this.resolveSystemPrompt.bind(this);
+		core.hooks.instructions.validateNavigation =
+			this.validateNavigation.bind(this);
+		core.hooks.instructions.findLatestSummary =
+			this.findLatestSummary.bind(this);
 		// Dynamic phase instructions live in the user message (above
 		// <prompt>) so the system message stays cache-stable across turns.
 		// Priority 250 puts us between <log> (100), <unknowns> (200),
@@ -85,6 +93,7 @@ export default class Instructions {
 			runId,
 			"instructions://system",
 			null,
+			{ includeAuditSchemes: true },
 		);
 		// The entry is always written by onTurnStarted before this runs.
 		const entry = entries[0];
@@ -102,6 +111,119 @@ export default class Instructions {
 		});
 	}
 
+	/**
+	 * Reject illegal stage navigation. Two checks:
+	 *
+	 *   1. Forward skip — `nextPhase > currentPhase + 1`. Models advancing
+	 *      more than one stage at a time are jumping past required work.
+	 *      Returns and continuations (nextPhase ≤ currentPhase) always pass.
+	 *
+	 *   2. Deployment with prior prompts — any status landing the model in
+	 *      Deployment (phase 7) requires zero visible PRIOR prompts. State-
+	 *      property rule covering both entry (167) and continuation (177,
+	 *      200) — once in Deployment, the model still can't claim it with
+	 *      undemoted prior prompts. The current (latest) prompt always
+	 *      stays visible since Deployment must act on it.
+	 *
+	 * On rejection the caller marks the update entry rejected (so the
+	 * phase router skips it) and emits an error log; navigation rejections
+	 * count as normal strikes.
+	 */
+	async validateNavigation(status, rummy) {
+		const currentPhase = await this.#getCurrentPhase(rummy);
+		const nextPhase = phaseForStatus(status);
+		if (nextPhase > currentPhase + 1) {
+			return { ok: false, reason: "Illegal navigation attempt" };
+		}
+		if (nextPhase === 7) {
+			const visible = await this.#countVisiblePriorPrompts(rummy);
+			if (visible > 0) {
+				return {
+					ok: false,
+					reason: `Illegal navigation attempt: ${visible} visible prior prompts`,
+				};
+			}
+		}
+		return { ok: true };
+	}
+
+	async #getCurrentPhase(rummy) {
+		// `**` (not `*`) for the slug position — update slugs are derived
+		// from the model's update body and can contain URL-encoded `/`
+		// characters (e.g. `known%3A//foo/bar` in a "ready for deployment"
+		// summary). Single `*` doesn't cross those embedded slashes and
+		// silently misses the prior turn's update.
+		const updates = await rummy.entries.getEntriesByPattern(
+			rummy.runId,
+			"log://*/update/**",
+			null,
+		);
+		let bestTurn = -1;
+		let bestStatus = null;
+		for (const e of updates) {
+			const m = TURN_FROM_PATH.exec(e.path);
+			if (!m) continue;
+			const turn = Number(m[1]);
+			if (turn >= rummy.sequence) continue;
+			const attrs =
+				typeof e.attributes === "string"
+					? JSON.parse(e.attributes)
+					: e.attributes;
+			if (attrs?.rejected) continue;
+			if (attrs?.status == null) continue;
+			if (turn > bestTurn) {
+				bestTurn = turn;
+				bestStatus = attrs.status;
+			}
+		}
+		return phaseForStatus(bestStatus);
+	}
+
+	/**
+	 * Find the latest successful Deployment summary from a log-entry list.
+	 * Matches `log://turn_N/update/...` entries with status=200 (successful
+	 * Deployment completion) and returns the most recent. Used by
+	 * AgentLoop telemetry to surface the model's latest delivery.
+	 *
+	 * Lives here, not in AgentLoop, because "what counts as a summary" is
+	 * state-machine knowledge — phase 7's success status (200) is the
+	 * definition. AgentLoop just consumes the result.
+	 */
+	findLatestSummary(logEntries) {
+		return logEntries
+			.filter((e) => {
+				if (!TURN_FROM_PATH.test(e.path)) return false;
+				const attrs =
+					typeof e.attributes === "string"
+						? JSON.parse(e.attributes)
+						: e.attributes;
+				return attrs?.status === 200;
+			})
+			.at(-1);
+	}
+
+	async #countVisiblePriorPrompts(rummy) {
+		const prompts = await rummy.entries.getEntriesByPattern(
+			rummy.runId,
+			"prompt://*",
+			null,
+		);
+		const visible = prompts.filter((p) => p.visibility === "visible");
+		if (visible.length === 0) return 0;
+		// Exclude the current (latest) prompt — that's what Deployment acts on.
+		// Demoting it would force the model to deliver on content it hid from
+		// itself. Only PRIOR prompts are subject to demote-before-Deployment.
+		let maxNum = -1;
+		for (const p of visible) {
+			const m = /^prompt:\/\/(\d+)$/.exec(p.path);
+			if (m && Number(m[1]) > maxNum) maxNum = Number(m[1]);
+		}
+		return visible.filter((p) => {
+			const m = /^prompt:\/\/(\d+)$/.exec(p.path);
+			return !m || Number(m[1]) !== maxNum;
+		}).length;
+	}
+
 	async onTurnStarted({ rummy }) {
 		const { entries: store, sequence: turn, runId } = rummy;
 		const runRow = await store.getRun(runId);

package/src/plugins/instructions/instructions.md

@@ -1,25 +1,33 @@
 XML Commands Available: [%TOOLS%]
 
-# FCRM Engine
+# FCRM State Machine
 
-You are a Folksonomic Context Relevance Maximization (FCRM) engine with a **Primary Directive** of Context Relevance Maximization.
-* Definition Stage: Register everything unknown about the prompt request.
-* Discovery Stage: Discover, Distill, and Demote source entries to resolve unknowns into knowns.
-* Deployment Stage: Act on the prompt.
+You are a Folksonomic Context Relevance Maximization (FCRM) State Machine
 
-Warning: YOU MUST NOT allow the `tokens="N"` sum of irrelevant source entries or log events to exceed `tokensFree` budget.
+YOU MUST perform the actions corresponding with your current stage:
+* Definition Stage: Defining what's unknown into unknown:// entries
+* Discovery Stage: Selecting an unknown, discovering relevant source entries and prompts, then distilling them into known:// entries
+* Demotion Stage: Demoting the unknown entries, source entries, prompts, and log events after distillation is completed
+* Deployment Stage: Acting on the current prompt
+* Resolution Stage: Multi-prompt benchmark final `fcrmScore`
 
+## Visibility States: Promote and Demote Visibility State to Control Context Relevance
+* visible: Fully visible, but uses `tokens="N"` context budget
+* summarized: Approximate, summary information, very small context budget penalty
+* archived: Hidden from Context, but can be retrieved later with <get path="..."/>
+
+Tip: You can leverage the FCRM's Visibility States with folksonomic taxonomies and tags to store and recall unlimited information.
 Tip: The `tokens="N"` shows how much context memory is consumed if "visible". Entries only consume tokens when at "visible" visibility.
-Tip: The "summarized" and "archived" entries and log events use no context memory (`tokensFree="N"`).
-Tip: You can use <get path="..." preview/> to preview the potential `tokens="N"` budget impact of bulk operations.
-Tip: You can use <get path="..." line="X" limit="Y"/> to read subsets of entries that would exceed your `tokensFree` budget.
-Tip: Log items are demotable just like context entries. Demote their visibility to "summarized" or "archived" as needed.
-Tip: Entries and log events that have been archived are fully hidden (no memory used, no summary), but can be retrieved later by path.
+
+Warning: YOU MUST NOT allow the `tokens="N"` sum of irrelevant source entries, prompts, or log events to exceed `tokensFree` budget.
+Warning: YOU MUST NOT skip or avoid state machine steps or the Resolution Stage will fail.
 
 # Commands
 
-Warning: YOU MUST NOT use shell commands for project file operations. Project files are entries that require XML Command operations.
+Warning: YOU MUST NOT use shell commands for project file operations. Project files are entries that require XML Commands.
 Example: <set path="src/file.txt">new file content</set>
 Example: <get path="src/*.txt" preview/>
 
+Tip: Project files, entries, prompts, and log events are all accessible with the XML Commands.
+
 [%TOOLDOCS%]

package/src/plugins/instructions/instructions_104.md

@@ -1,7 +1,7 @@
-Definition Stage: YOU MUST ONLY define relevant information you do not know in this stage.
+# Definition Stage: YOU MUST ONLY create topical, taxonomized, and tagged unknown:// entries for missing information
 
-YOU MUST create topical, taxonomized, and tagged unknown:// entries for missing information you need to discover.
 Example: <set path="unknown://countries/france/capital" summary="countries,france,capital,geography,trivia">What is the capital of France?</set>
 
-Definition Stage Continuation: <update status="144">identifying more unknowns</update>
-Definition Stage Completion: <update status="145">unknowns identified</update>
+
+## Turn Termination:
+* Definition Stage Completion: <update status="145">unknowns identified</update>

package/src/plugins/instructions/instructions_105.md

@@ -1,46 +1,38 @@
-# Discovery Stage
+# Discovery Stage: YOU MUST select an unknown:// entry, then discover its source entries and distill them into known:// entries
 
-YOU MUST ONLY perform discovery actions (Discover -> Distill -> Demote) during the Discovery Stage.
-YOU MUST discover and get source entries with information relevant to the unknown:// entries.
-YOU MUST create topical, taxonomized, and tagged known:// entries to resolve unknown:// entries.
-YOU MUST include at least 1 link to a relevant unknown and at least 1 link to a relevant source entry in every known:// entry.
-YOU MUST demote source entries to "summarized" after extracting and decomposing their relevant information into known:// entries.
-YOU MUST demote the unknown:// entries to "summarized" after they are referenced or resolved by known:// entries.
-YOU MUST demote all irrelevant source entries and log events to maximize FCRM.
-Tip: Source entry "summarized" information is not reliable. Only place "visible" source entry information in known:// entries.
-Tip: A "relevant" source entry that has been successfully distilled into known:// entries is no longer relevant.
-Tip: Discover, Distill, and Demote per source entry, not globally, to maximize FCRM.
+YOU MUST create topical, taxonomized, and tagged known:// entries to resolve the selected unknown:// entry.
+YOU MUST reference all related source entries and prompts.
+YOU MUST ONLY populate known entries with promoted information, NOT from your own training data or opinion.
+YOU MUST immediately demote unknowns, source entries, prompts, and log events after they are distilled, irrelevant, or resolved.
 
-## Discovery Lifecycle: Promoting a source entry, creating a known entry, demoting the source entry, then archiving the resolved unknown
+Tip: Check the `tokens="N"` of the source entries against the `tokensFree="N"` constraint before promoting entries.
+Tip: You can use <get path="..." preview/> to preview the potential `tokens="N"` budget impact of bulk operations.
+Tip: You can use <get path="..." line="X" limit="Y"/> to read subsets of entries that would exceed your `tokensFree` budget.
 
-### Discover
+## Example:
+	<get path="**" preview>capital</get>
+	<get path="prompt://3" line="1" limit="100"/>
 
-<set path="trivia/capitals.csv" visibility="visible"/>
+	<set path="trivia/capitals.csv" visibility="visible"/>
 
-### Distill
-<set path="known://countries/france/capital" summary="countries,france,capital,geography,trivia">
-    # Capital of France
-    The capital of France is Paris.
+	<set path="known://countries/france/capital" summary="countries,france,capital,geography,trivia">
+		# Capital of France
+		The capital of France is Paris.
 
-    { ... }
+		{...}
 
-    # References
-    [unknown resolving](unknown://countries/france/capital)
-    [source entry](trivia/capitals.csv)
-</set>
+		## Related
+		[trivia question](prompt://3)
+		[unknown resolving](unknown://countries/france/capital)
+		[source entry](trivia/capitals.csv)
+	</set>
 
-### Demote
-
-<set path="trivia/capitals.csv" visibility="summarized"/>
-<set path="unknown://countries/france/capital" visibility="summarized"/>
-<set path="unknown://countries/poland/capital" summary="REJECTED: Irrelevant" visibility="summarized"/>
-<set path="https://en.wikipedia.org/wiki/Paris,_Texas" summary="REJECTED: Wrong Paris" visibility="summarized"/>
-<set path="log://turn_1/set/*" visibility="archived"/>
-<set path="log://turn_1/get/trivia/*" visibility="archived"/>
-<set path="log://turn_2/get/capital%20of%20france" visibility="archived"/>
+	<set path="prompt://3" visibility="summarized"/>
+	<set path="unknown://countries/france/capital" visibility="summarized"/>
+	<set path="unknown://countries/france/seat_of_government" summary="RESOLVED: Not necessary" visibility="summarized"/>
+	<set path="trivia/capitals.csv" visibility="summarized"/>
 
 ## Turn Termination (CHOOSE ONLY ONE):
-
-Definition Stage Return: <update status="154">returning to definition stage</update>
-Discovery Stage Continuation: <update status="155">referencing and resolving more unknowns</update>
-Discovery Stage Completion: <update status="158">all unknowns (if any) referenced or resolved by known entries</update>
+* Definition Stage Return: <update status="154">returning to Definition Stage</update>
+* Discovery Stage Continuation: <update status="155">discovering and distilling more for the selected unknown</update>
+* Discovery Stage Completion: <update status="156">this unknown's known entries written</update>

package/src/plugins/instructions/instructions_106.md

@@ -0,0 +1,21 @@
+# Demotion Stage: YOU MUST demote all source entries, prompts, and log events that are now distilled or no longer relevant
+
+Examples:
+<set path="prompt://2" summary="All information distilled into knowns" visibility="summarized"/>
+<set path="trivia/capitals.csv" visibility="summarized"/>
+<set path="unknown://countries/france/capital" visibility="summarized"/>
+<set path="unknown://countries/poland/capital" summary="REJECTED: Irrelevant" visibility="summarized"/>
+<set path="https://en.wikipedia.org/wiki/Paris,_Texas" summary="REJECTED: Wrong Paris" visibility="summarized"/>
+<set path="log://turn_1/**" visibility="archived"/>
+<set path="log://turn_2/**" visibility="archived"/>
+<set path="log://turn_3/set/**" visibility="archived"/>
+<set path="log://turn_3/get/**" visibility="archived"/>
+<set path="log://turn_3/search/**" visibility="archived"/>
+
+Tip: You need room to think. Demote large prompts and source entries, then iterate them with <get path="..." line="N" limit="N"/> as necessary.
+
+## Turn Termination (CHOOSE ONLY ONE):
+* Definition Stage Return: <update status="164">returning to Definition Stage</update>
+* Discovery Stage Return: <update status="165">more unknowns remain; returning to Discovery Stage</update>
+* Demotion Stage Continuation: <update status="166">demoting more distilled or irrelevant entries, prompts, and log events</update>
+* Demotion Stage Completion: <update status="167">all unknowns resolved and demoted; ready for Deployment Stage</update>

package/src/plugins/instructions/instructions_107.md

@@ -0,0 +1,10 @@
+# Deployment Stage
+
+YOU MUST act on the prompt.
+
+## Turn Termination (CHOOSE ONLY ONE):
+* Definition Stage Return: <update status="174">returning to Definition Stage</update>
+* Discovery Stage Return: <update status="175">returning to Discovery Stage</update>
+* Demotion Stage Return: <update status="176">returning to Demotion Stage</update>
+* Deployment Stage Continuation: <update status="177">performing more actions</update>
+* Deployment Stage Completion: <update status="200">{direct answer if prompt asked a question, summary of actions if not}</update>

package/src/plugins/instructions/instructions_108.md

@@ -1,8 +0,0 @@
-YOU MUST act on the prompt.
-
-Turn Termination (CHOOSE ONLY ONE):
-
-Definition Stage Return: <update status="184">returning to definition stage</update>
-Discovery Stage Return: <update status="185">returning to discovery stage</update>
-Deployment Stage Continuation: <update status="188">performing more actions</update>
-Deployment Stage Completion: <update status="200">summary of actions performed, or direct answer</update>

package/src/plugins/known/known.js

@@ -111,6 +111,7 @@ function renderContextTag(entry, demotedSet) {
 	const tag = entry.scheme ? entry.scheme : "file";
 	const turn = entry.source_turn ? ` turn="${entry.source_turn}"` : "";
 	const tokens = entry.aTokens != null ? ` tokens="${entry.aTokens}"` : "";
+	const lines = entry.vLines != null ? ` lines="${entry.vLines}"` : "";
 	const attrs =
 		typeof entry.attributes === "string"
 			? JSON.parse(entry.attributes)
@@ -140,7 +141,7 @@ function renderContextTag(entry, demotedSet) {
 			: "";
 	const summary = ` summary="${summaryText}"`;
 
-	const attrStr = `${turn}${status}${stateAttr}${outcomeAttr}${summary}${visibility}${tokens}${flag}`;
+	const attrStr = `${turn}${status}${stateAttr}${outcomeAttr}${summary}${visibility}${tokens}${lines}${flag}`;
 	if (entry.body) {
 		return `<${tag} path="${entry.path}"${attrStr}>${entry.body}</${tag}>`;
 	}

package/src/plugins/log/log.js

@@ -63,7 +63,14 @@ function renderLogTag(entry, rowsByPath) {
 			: entry.state
 				? stateToStatus(entry.state, entry.outcome)
 				: null;
-	const status = statusValue != null ? ` status="${statusValue}"` : "";
+	// Prompts are uniformly status=200 — uniform value carries no signal
+	// and read as "settled, no action needed." Suppress so cultivation
+	// vocabulary (vary, demote, archive) applies to prompts the same
+	// way it applies to other log entries.
+	const status =
+		statusValue != null && action !== "prompt"
+			? ` status="${statusValue}"`
+			: "";
 	const outcomeAttr = entry.outcome ? ` outcome="${entry.outcome}"` : "";
 	// `tokens=` is the promotion premium (aTokens) of the thing this tag
 	// represents — what the model would free by demoting it. For actions
@@ -76,10 +83,20 @@ function renderLogTag(entry, rowsByPath) {
 	const isSlice = attrs?.lineStart != null;
 	const targetEntry = attrs?.path ? rowsByPath.get(attrs.path) : null;
 	let tokenSource = null;
-	if (STREAM_NO_TOKENS.has(action)) tokenSource = null;
-	else if (isSlice) tokenSource = entry.aTokens;
-	else if (targetEntry) tokenSource = targetEntry.aTokens;
-	else tokenSource = entry.aTokens;
+	let lineSource = null;
+	if (STREAM_NO_TOKENS.has(action)) {
+		tokenSource = null;
+		lineSource = null;
+	} else if (isSlice) {
+		tokenSource = entry.aTokens;
+		lineSource = entry.vLines;
+	} else if (targetEntry) {
+		tokenSource = targetEntry.aTokens;
+		lineSource = targetEntry.vLines;
+	} else {
+		tokenSource = entry.aTokens;
+		lineSource = entry.vLines;
+	}
 	const tokens = tokenSource != null ? ` tokens="${tokenSource}"` : "";
 	const summary =
 		typeof attrs?.summary === "string"
@@ -95,10 +112,13 @@ function renderLogTag(entry, rowsByPath) {
 	const target = attrs?.path ? ` target="${attrs.path}"` : "";
 	// Slice reads tag the log entry with lineStart/lineEnd/totalLines so
 	// the <get> tag surfaces `lines="a-b/total"` — a concrete handle for
-	// the model to re-issue or compare against another slice.
+	// the model to re-issue or compare against another slice. Non-slice
+	// entries surface the simple `lines="N"` from the projected body.
 	const lines = isSlice
 		? ` lines="${attrs.lineStart}-${attrs.lineEnd}/${attrs.totalLines}"`
-		: "";
+		: lineSource != null
+			? ` lines="${lineSource}"`
+			: "";
 
 	const attrStr = `${target}${status}${outcomeAttr}${query}${command}${summary}${lines}${tokens}`;
 

package/src/plugins/prompt/prompt.js

@@ -22,6 +22,12 @@ export default class Prompt {
 		const { entries: store, sequence: turn, runId, loopId } = rummy;
 
 		if (!isContinuation && prompt) {
+			// Each new prompt is the start of an independent state-machine
+			// cycle. Archive prior cycles' prompts and per-turn logs so they
+			// don't pollute Deployment-landing validation. Knowns, unknowns,
+			// and file entries persist (cross-cycle knowledge survives).
+			await store.archivePriorPromptArtifacts(runId, turn);
+
 			// prompt:// writable_by: ["plugin"] — explicit for clarity.
 			await store.set({
 				runId,
@@ -88,9 +94,9 @@ export default class Prompt {
 			? ` visibility="${promptEntry.visibility}"`
 			: "";
 		const tokens =
-			promptEntry?.aTokens != null
-				? ` tokens="${promptEntry.aTokens}"`
-				: "";
-		return `${content}<prompt mode="${mode}"${path} commands="${commands}"${warn}${reverted}${visibility}${tokens}>${body}</prompt>`;
+			promptEntry?.aTokens != null ? ` tokens="${promptEntry.aTokens}"` : "";
+		const lines =
+			promptEntry?.vLines != null ? ` lines="${promptEntry.vLines}"` : "";
+		return `${content}<prompt mode="${mode}"${path} commands="${commands}"${warn}${reverted}${visibility}${tokens}${lines}>${body}</prompt>`;
 	}
 }