@possumtech/rummy 2.0.0 → 2.1.0

package/src/plugins/hedberg/patterns.js

@@ -313,10 +313,7 @@ function collectDescendants(node, out) {
 
 // --- Public API ---
 
-/**
- * hedmatch — does the pattern match the ENTIRE string?
- * For path matching, WHERE clauses, full-string comparison.
- */
+// hedmatch — full-string match (path, WHERE clause).
 export function hedmatch(pattern, string) {
 	if (string === null) return false;
 
@@ -345,11 +342,7 @@ export function hedmatch(pattern, string) {
 	return false;
 }
 
-/**
- * hedsearch — find the pattern anywhere IN the string.
- * For substring search, content filtering, "does this text contain...".
- * Returns { found, match, index } or { found: false }.
- */
+// hedsearch — substring match → { found, match, index }.
 export function hedsearch(pattern, string) {
 	if (string === null) return { found: false };
 
@@ -400,10 +393,7 @@ export function hedsearch(pattern, string) {
 	return { found: false };
 }
 
-/**
- * hedreplace — find pattern in string, replace with replacement.
- * Returns the new string, or null if pattern not found.
- */
+// hedreplace — substitute; null when pattern not found.
 export function hedreplace(pattern, replacement, string) {
 	if (string === null) return null;
 
@@ -446,5 +436,4 @@ export function hedreplace(pattern, replacement, string) {
 	return null;
 }
 
-// SQL functions are in separate files (hedmatch.js, hedsearch.js)
-// that import from this library. Filename = SQL function name.
+// SQL functions live in sibling files; filename = SQL function name.

package/src/plugins/hedberg/sed.js

@@ -1,10 +1,4 @@
-/**
- * Sed syntax parsing. Handles s/search/replace/flags with:
- * - Escaped delimiters (\\/)
- * - Chained commands (s/a/b/ s/c/d/)
- * - Flag extraction (g, i, m, s, v)
- */
-
+// Parses s/search/replace/flags with escaped delimiters, chains, and g/i/m/s/v flags.
 function splitSed(str, delim) {
 	const parts = [];
 	let current = "";

package/src/plugins/helpers.js

@@ -2,13 +2,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-/**
- * Read a sibling tooldoc markdown file and return its model-facing text.
- * Strips HTML comments (rationale stays in source, never reaches the model)
- * and collapses any blank-line runs left behind. Each plugin's Doc.js is a
- * one-liner that defers to this so authors edit normal markdown instead of
- * a JS array of [text, rationale] pairs.
- */
+// Read sibling tooldoc .md; strips HTML comments (rationale stays out of the model packet).
 export function loadDoc(metaUrl, name) {
 	const dir = dirname(fileURLToPath(metaUrl));
 	return readFileSync(join(dir, name), "utf8")
@@ -17,23 +11,37 @@ export function loadDoc(metaUrl, name) {
 		.trim();
 }
 
-/**
- * Translate a log entry path into its companion data-scheme base path.
- * `log://turn_N/{action}/{rest}` → `{action}://turn_N/{rest}`.
- * Streaming producers (sh, env) create data channel entries under the
- * producer scheme while the audit record lives in the log scheme; this
- * helper bridges the two namespaces. Returns null for non-log paths.
- */
+// log://turn_N/{action}/{rest} → {action}://turn_N/{rest}; null if not a log path.
 export function logPathToDataBase(logPath) {
 	const m = logPath?.match(/^log:\/\/turn_(\d+)\/([^/]+)\/(.+)$/);
 	if (!m) return null;
 	return `${m[2]}://turn_${m[1]}/${m[3]}`;
 }
 
-/**
- * Shared helper for pattern-based tool results.
- * Used by get, set, store, and rm tools.
- */
+// env/sh stdout/stderr summary projection: header with line range + last
+// TAIL_LINES of body. The header tells the model exactly which slice is
+// shown so it can issue <get line="N" limit="M"/> for the rest without
+// re-running the command.
+export function streamSummary(label, entry, TAIL_LINES = 12) {
+	if (!entry.body) return "";
+	const { body, attributes } = entry;
+	const command = attributes.command;
+	const channel = attributes.channel === 2 ? "stderr" : "stdout";
+	const trailingNewline = body.endsWith("\n");
+	const lines = trailingNewline
+		? body.slice(0, -1).split("\n")
+		: body.split("\n");
+	const total = lines.length;
+	if (total <= TAIL_LINES) {
+		return `# ${label} ${command} (${channel}, ${total}L)\n${body}`;
+	}
+	const startLine = total - TAIL_LINES + 1;
+	const tail =
+		lines.slice(-TAIL_LINES).join("\n") + (trailingNewline ? "\n" : "");
+	return `# ${label} ${command} (${channel}, tail L${startLine}-${total}/${total}; <get line="1" limit="N"/> for head)\n${tail}`;
+}
+
+// Pattern-result log entry shared by get/set/store/rm.
 export async function storePatternResult(
 	store,
 	runId,
@@ -42,13 +50,13 @@ export async function storePatternResult(
 	path,
 	bodyFilter,
 	matches,
-	{ preview = false, loopId = null, attributes = null } = {},
+	{ manifest = false, loopId = null, attributes = null } = {},
 ) {
 	const logSlug = await store.logPath(runId, turn, scheme, path);
 	const filter = bodyFilter ? ` body="${bodyFilter}"` : "";
 	const total = matches.reduce((s, m) => s + m.tokens, 0);
 	const listing = matches.map((m) => `${m.path} (${m.tokens})`).join("\n");
-	const prefix = preview ? "PREVIEW " : "";
+	const prefix = manifest ? "MANIFEST " : "";
 	const body = `${prefix}${scheme} path="${path}"${filter}: ${matches.length} matched (${total} tokens)\n${listing}`;
 	await store.set({
 		runId,

package/src/plugins/index.js

@@ -3,28 +3,18 @@ import { existsSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import { basename, isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
+import config from "../agent/config.js";
 import PluginContext from "../hooks/PluginContext.js";
 
+const { PLUGINS_LOAD_TIMEOUT } = config;
+
 let globalPrefix;
 function getGlobalPrefix() {
 	globalPrefix ??= execSync("npm prefix -g", { encoding: "utf8" }).trim();
 	return globalPrefix;
 }
 
-/**
- * Plugin loader:
- *   1. Walk filesystem + env vars to collect plugin descriptors.
- *   2. Import each and instantiate with a fresh PluginContext.
- *
- * Returns a Map of name → PluginContext for the caller to pass to
- * initPlugins. No module-global state — each caller owns its set.
- *
- * Plugin constructors must be declarative (SPEC surfaces): they
- * register schemes, hooks, filters, RPC methods — but don't dereference
- * infrastructure that might not be ready yet. Because the plugin
- * contract makes constructors side-effect-free on each other, load
- * order doesn't matter and there is no dependency system.
- */
+// Walk filesystem + env vars, import, instantiate; constructors must stay declarative.
 export async function registerPlugins(dirs = [], hooks) {
 	const uniqueDirs = [...new Set(dirs.map((d) => join(d)))];
 
@@ -39,12 +29,22 @@ export async function registerPlugins(dirs = [], hooks) {
 		try {
 			const module = await withTimeout(
 				import(d.url),
-				PLUGIN_LOAD_TIMEOUT,
+				PLUGINS_LOAD_TIMEOUT,
 				`Plugin import timed out: ${d.source}`,
 			);
 			resolved.push({ ...d, Plugin: module.default });
 		} catch (err) {
-			console.warn(`[RUMMY] Plugin import failed: ${d.name} — ${err.message}`);
+			// Core plugins live on disk and are part of rummy's contract;
+			// their failure is structural and must crash. Third-party
+			// plugins (RUMMY_PLUGIN_<x>) are user-installed and may be
+			// busted; we log loudly and continue without them.
+			if (d.source.startsWith("env:")) {
+				console.error(
+					`[RUMMY] Plugin import failed: ${d.name} — ${err.message}`,
+				);
+				continue;
+			}
+			throw new Error(`Core plugin '${d.name}' import failed`, { cause: err });
 		}
 	}
 
@@ -53,7 +53,11 @@ export async function registerPlugins(dirs = [], hooks) {
 		try {
 			await instantiatePlugin(r, hooks, instances);
 		} catch (err) {
-			console.warn(`[RUMMY] Plugin load failed: ${r.name} — ${err.message}`);
+			if (r.source.startsWith("env:")) {
+				console.error(`[RUMMY] Plugin load failed: ${r.name} — ${err.message}`);
+				continue;
+			}
+			throw new Error(`Core plugin '${r.name}' load failed`, { cause: err });
 		}
 	}
 	return instances;
@@ -63,7 +67,7 @@ async function instantiatePlugin({ name, Plugin, source }, hooks, instances) {
 	if (typeof Plugin?.register === "function") {
 		await withTimeout(
 			Plugin.register(hooks),
-			PLUGIN_LOAD_TIMEOUT,
+			PLUGINS_LOAD_TIMEOUT,
 			`Plugin register timed out: ${source}`,
 		);
 		return;
@@ -89,26 +93,14 @@ const AUDIT_SCHEMES = [
 
 const PROMPT_SCHEMES = ["prompt"];
 
-// Lifecycle schemes: client-addressable entries that reflect server
-// state. Writable by system (internal bookkeeping), plugin (extensions),
-// and client (RPC in Phase 4).
+// Lifecycle entries mirror server state; writable by system/plugin/client.
 const LIFECYCLE_SCHEMES = ["run"];
 
-// Unified log namespace for action history entries under
-// log://turn_N/scheme/slug.
 const LOG_SCHEMES = ["log"];
 
-/**
- * After DB is ready, upsert declared schemes and bootstrap audit/prompt
- * schemes. Takes the plugin collection returned by registerPlugins.
- * Per-plugin store/db access is provided per-turn via RummyContext;
- * PluginContext itself holds only name + hooks.
- */
+// Bootstraps audit/prompt/log/lifecycle schemes; called after DB is ready.
 export async function initPlugins(db, hooks, instances) {
 	for (const name of AUDIT_SCHEMES) {
-		// Audit schemes are written only by system-level code (reasoning,
-		// user/assistant/model messages, etc.). Closing the door on model
-		// writes and plugin writes here.
 		await db.upsert_scheme.run({
 			name,
 			model_visible: 0,
@@ -118,8 +110,6 @@ export async function initPlugins(db, hooks, instances) {
 		});
 	}
 	for (const name of PROMPT_SCHEMES) {
-		// Prompt entries are created by the prompt plugin on user input;
-		// model doesn't emit <set path="prompt://...">.
 		await db.upsert_scheme.run({
 			name,
 			model_visible: 1,
@@ -138,9 +128,6 @@ export async function initPlugins(db, hooks, instances) {
 		});
 	}
 	for (const name of LIFECYCLE_SCHEMES) {
-		// Lifecycle entries are client-addressable mirrors of server state.
-		// Not model-visible. System writes internally; plugins and clients
-		// write via the 6 primitives.
 		await db.upsert_scheme.run({
 			name,
 			model_visible: 0,
@@ -156,7 +143,7 @@ export async function initPlugins(db, hooks, instances) {
 		}
 	}
 
-	// Register default schemes for tools that plugins ensured but didn't registerScheme for
+	// Default scheme for tools that ensureTool'd but didn't registerScheme.
 	const registered = new Set();
 	for (const ctx of instances.values()) {
 		for (const s of ctx.schemes) registered.add(s.name);
@@ -177,7 +164,6 @@ export async function initPlugins(db, hooks, instances) {
 }
 
 function resolvePlugin(packageName) {
-	// Check local node_modules first, then global
 	const localDir = join(process.cwd(), "node_modules", packageName);
 	if (existsSync(join(localDir, "package.json"))) return localDir;
 	const globalDir = join(getGlobalPrefix(), "lib", "node_modules", packageName);
@@ -256,8 +242,6 @@ async function collectFromDir(dir, isRoot, descriptors) {
 	}
 }
 
-const PLUGIN_LOAD_TIMEOUT = 10000;
-
 function withTimeout(promise, ms, message) {
 	return Promise.race([
 		promise,

package/src/plugins/instructions/README.md

@@ -29,6 +29,24 @@ phase directive so prompt caching holds across turns within a run.
 - `protocol.js` — placeholder module reserved for deterministic
   protocol rule enforcement. Currently pass-through.
 
+## Navigation validation
+
+`validateNavigation(status, rummy)` rejects illegal stage transitions
+emitted via `<update status="N">`:
+
+- **Forward skip** — `nextPhase > currentPhase + 1`. Models advancing
+  more than one stage at once are jumping past required work. Returns
+  and continuations (`nextPhase ≤ currentPhase`) always pass.
+- **Status 200 outside Deployment** — 200 is Deployment Completion.
+  Emitting it from earlier phases skips the actual Deployment work.
+- **Deployment with prior prompts** — entering or remaining in
+  Deployment (phase 7) requires zero visible PRIOR prompts. Covers
+  167 (entry), 177 / 200 (continuation, completion).
+
+On rejection the update entry is marked `rejected` (the phase router
+skips it) and an error log is emitted; rejections count as normal
+strikes.
+
 ## Cache shape
 
 - System message includes the base template + tool docs + persona.

package/src/plugins/instructions/instructions.js

@@ -6,12 +6,7 @@ const baseInstructions = readFileSync(
 	"utf8",
 );
 
-// 1XY status encoding: X=current phase, Y=next phase. Y routes through
-// phaseForStatus to select next turn's <instructions>. Phases 4–9 are
-// reserved (status codes 1X4..1X9); add new phases by dropping in
-// `instructions_10N.md`. Absent files render no <instructions> block —
-// the model runs on base instructions only. This lets you route ahead
-// of writing the prose (e.g. an upcoming "ask lite" phase 9).
+// 1XY phase routing; see plugin README.
 const PHASES = [4, 5, 6, 7, 8, 9];
 const phaseInstructions = Object.fromEntries(
 	PHASES.flatMap((p) => {
@@ -23,19 +18,12 @@ 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;
 }
 
-// Scan an already-materialized row set for the most recent update
-// emission's status. Used by the assembly.user filter so the phase
-// instructions ride with the user message (dynamic, expected to
-// change every turn) instead of the system prompt (stable, cached).
-// Validation is upstream (update.js isValidStatus + 422 error log) so
-// we trust the status and route on it directly — a whitelist here
-// silently drops advertised completion codes whose contracts drift,
-// which is worse than a noisy fallback.
+// Latest non-rejected update status from materialized rows.
 function latestUpdateStatusFromRows(rows) {
 	let bestTurn = -1;
 	let bestStatus = null;
@@ -49,6 +37,7 @@ function latestUpdateStatusFromRows(rows) {
 				: r.attributes;
 		const status = attrs?.status;
 		if (status == null) continue;
+		if (attrs?.rejected) continue;
 		if (turn > bestTurn || (turn === bestTurn && status > bestStatus)) {
 			bestTurn = turn;
 			bestStatus = status;
@@ -66,25 +55,22 @@ export default class Instructions {
 		core.on("turn.started", this.onTurnStarted.bind(this));
 		core.hooks.instructions.resolveSystemPrompt =
 			this.resolveSystemPrompt.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),
-		// and <prompt> (300).
-		core.filter("assembly.user", this.assembleInstructions.bind(this), 250);
+		core.hooks.instructions.validateNavigation =
+			this.validateNavigation.bind(this);
+		core.hooks.instructions.findLatestSummary =
+			this.findLatestSummary.bind(this);
+		core.filter("assembly.user", this.assembleInstructions.bind(this), 200);
 		new Protocol(core);
 	}
 
-	/**
-	 * Materialize the system prompt for a run: look up the
-	 * instructions://system entry, project it through the promoted view.
-	 * TurnExecutor calls this once per turn before context assembly.
-	 */
+	// Project instructions://system through the visible view; called once per turn.
 	async resolveSystemPrompt(rummy) {
 		const { entries: store, runId, hooks } = rummy;
 		const entries = await store.getEntriesByPattern(
 			runId,
 			"instructions://system",
 			null,
+			{ includeAuditSchemes: true },
 		);
 		// The entry is always written by onTurnStarted before this runs.
 		const entry = entries[0];
@@ -102,16 +88,97 @@ export default class Instructions {
 		});
 	}
 
+	// Reject illegal stage navigation; see plugin README.
+	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 (status === 200 && currentPhase !== 7) {
+			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 `*`: update slugs may contain URL-encoded `/`.
+		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);
+	}
+
+	// Latest phase-7 success (status=200); state-machine knowledge lives here, not AgentLoop.
+	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 latest prompt; only PRIOR prompts trigger 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);
 		const toolSet = rummy.toolSet
 			? [...rummy.toolSet]
 			: this.#core.hooks.tools.names;
-		// instructions:// is an audit scheme (writable_by: ["system"]).
-		// No per-turn phase state on this entry — keeps the system
-		// prompt cache-stable across turns. Phase selection happens at
-		// assembly.user time from the current row set.
+		// instructions://system stays cache-stable; phase selection at assembly.user.
 		await store.set({
 			runId,
 			turn,
@@ -120,8 +187,6 @@ export default class Instructions {
 			state: "resolved",
 			writer: "system",
 			attributes: {
-				// runRow.persona is a nullable TEXT column; absent row is
-				// a system bug — let the null propagate if runRow exists.
 				persona: runRow.persona,
 				toolSet,
 			},
@@ -137,7 +202,6 @@ export default class Instructions {
 			{},
 			{ toolSet: activeTools },
 		);
-		// Hidden tools are excluded at the registry level (see ToolRegistry).
 		const sorted = this.#core.hooks.tools.advertisedNames.filter((n) =>
 			activeTools.has(n),
 		);
@@ -153,12 +217,7 @@ export default class Instructions {
 		return prompt;
 	}
 
-	// Renders the current phase's instructions as an <instructions>
-	// block in the user message. Runs at priority 250 — after <log>
-	// and <unknowns>, immediately before <prompt>. System prompt stays
-	// static so prompt caching keeps its prefix intact across turns.
-	// A routed phase without an instructions_10N.md file emits nothing —
-	// the model proceeds on base instructions alone.
+	// Render <instructions> for current phase; absent phase file → no block.
 	assembleInstructions(content, ctx) {
 		const status = latestUpdateStatusFromRows(ctx.rows);
 		const step = phaseInstructions[phaseForStatus(status)];

package/src/plugins/instructions/instructions.md

@@ -1,25 +1,34 @@
 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 ONLY perform the actions corresponding with your current stage:
+* Decomposition Stage: Determine, define, and decompose key unknown and unresolved into unknown:// entries
+* Distillation Stage: discovering relevant source entries, then distilling into known:// entries to resolve unknowns
+* Demotion Stage: Demote the unknown entries, source entries, prompts, and log events after distillation is completed
+* Deployment Stage: Act on the current prompt after relevant context is distilled and irrelevant context is demoted
+* Resolution Stage: Evaluation of context relevance maximization, state machine compliance, and prompt resolution.
 
-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.
+## Visibility States: Promote and Demote Visibility State to Control Context Relevance
+* visible: Full entry body in context, uses `tokens="N"` context budget
+* summarized: Short summary in context, very small context budget penalty
+* archived: Hidden from context, recallable later by path reference or pattern search
+
+* Leverage the FCRM's Visibility States with folksonomic taxonomies and tags to store and recall unlimited information.
+* When an entry is "visible", it will appear in both the summarized and visible sections.
+* The `tokens="N"` shows how much context is consumed if "visible". Entries consume very few tokens when summarized.
+
+YOU MUST NOT allow the `tokens="N"` sum of source entries, prompts, or log events to exceed `tokensFree` budget.
 
 # Commands
 
-Warning: YOU MUST NOT use shell commands for project file operations. Project files are entries that require XML Command operations.
-Example: <set path="src/file.txt">new file content</set>
-Example: <get path="src/*.txt" preview/>
+YOU MUST NOT use shell commands for file operations. Files are also entries that require XML Commands.
+Example: <set path="projectFile.txt">new file content</set>
+Example: <get path="src/*.txt" manifest/>
+
+* Files, entries, prompts, and log events are all accessible with the XML Commands.
+* Entries without a `{scheme}://` are files. They can be read and modified through the unified XML Commands interface.
 
 [%TOOLDOCS%]

package/src/plugins/instructions/instructions_104.md

@@ -1,7 +1,8 @@
-Definition Stage: YOU MUST ONLY define relevant information you do not know in this stage.
+# Decomposition Stage: YOU MUST ONLY create topical, taxonomized, and tagged unknown:// entries
+
+YOU MUST decompose the prompt into the key information, issues, and items that are unknown and/or unresolved.
 
-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 (CHOOSE ONLY ONE):
+* Decomposition Stage Completion: <update status="145">prompt decomposed</update>