omp-onlyne 0.1.0 → 0.3.0

package/src/decider.ts

@@ -8,8 +8,8 @@ import {
 	type Action,
 	type DeliveryPlan,
 	type Entry,
+	type JoinedThread,
 	type Json,
-	type MessageRef,
 	type MsgInput,
 	type NodeId,
 	type Page,
@@ -19,26 +19,42 @@ import {
 	OnlyneError,
 } from "@onlyne/lib";
 import { getLocale } from "@onlyne/node-host/i18n";
-import type { ContextRecord, OnlyneConfig } from "./types.ts";
-import { canAnswer, type ContextRegistry } from "./store.ts";
+import { isTrustThread } from "./handshake.ts";
+import type { ContextRecord, OnlyneConfig } from "@onlyne/node-host/types";
+import { canAnswer, type ContextRegistry } from "@onlyne/node-host/store";
 import { text } from "./decider-text.ts";
+import { ActionGuard, settleIntent, type OutboundIntent } from "./guard.ts";
+import { continueThread, inheritedModes, resolvedModes, resourceAction, resourceFields, sendAction } from "./plan.ts";
+import {
+	choice,
+	contextQuestions,
+	domainOpQuestions,
+	insertionQuestions,
+	intentQuestions,
+	needsAnswerQuestions,
+	originalQuestions,
+	planQuestions,
+	readScopeQuestions,
+	relationQuestions,
+	targetQuestions,
+	threadOpQuestions,
+	threadQuestions,
+	type Answers,
+	type Questions,
+} from "./questions.ts";
+import {
+	References,
+	knownPeers,
+	lastSegment,
+	threadKey,
+	type PeerRecord,
+	type ReplyReference,
+} from "./resolve.ts";
 
 type Row = Record<string, unknown>;
 
-interface ChoiceQuestion {
-	type: "choice";
-	instructions: string;
-	criteria: Record<string, string>;
-}
-
-type Questions = Record<string, ChoiceQuestion>;
-
-interface ChoiceAnswer {
-	type?: string;
-	choice?: string;
-}
-
-type Answers = Record<string, ChoiceAnswer | undefined>;
+export type { Answers, Questions } from "./questions.ts";
+export type { PeerRecord } from "./resolve.ts";
 
 /** A decision input that either carries its records or states why it has none. */
 type Source<T> = { available: true; value: T } | { available: false; reason: string };
@@ -57,14 +73,6 @@ function valueOf<T>(source: unknown): T | undefined {
 	return row.value as T;
 }
 
-/** One discovered peer, as the library's discovery records it. */
-export interface PeerRecord {
-	node_id: NodeId;
-	base_url: string;
-	instance_id: string;
-	last_seen: string;
-}
-
 /** One execution context a receiving node publishes for a target-qualified delivery. */
 export interface ReceiverContext {
 	alias: string;
@@ -106,6 +114,8 @@ export function currentDecision(): DecisionScope | undefined {
 	return decisionScope.getStore();
 }
 
+export { knownPeers, reuseThread } from "./resolve.ts";
+
 export interface DeciderDeps {
 	config: OnlyneConfig;
 	/** Registry id of this node's main session; children are bound under it. */
@@ -113,12 +123,22 @@ export interface DeciderDeps {
 	contexts: ContextRegistry;
 	log?(message: string, fields: Record<string, unknown>): void;
 	listThreads(): Promise<Thread[]>;
+	/** The threads this node was invited into; they live on their owner, never here. */
+	listJoinedThreads(): Promise<JoinedThread[]>;
 	listMessages(thread: ThreadRef, cursor?: string): Promise<Page<Entry>>;
+	/** The peers one thread already lists as members; a send reuses the thread a peer belongs to. */
+	threadMembers(thread: ThreadRef): Promise<NodeId[]>;
 	/** Peers from the library's live discovery records, never a static configuration. */
 	listPeers(): Promise<PeerRecord[]>;
+	/** Every trust row this node holds, in any phase. Identity outlives a discovery record. */
+	listTrust(): Promise<Array<{ node_id: NodeId; phase: string; base_url?: string }>>;
+	/** The inbound records this node holds; O-2A's candidate set reads the entries from them. */
+	listInbox(): Promise<Array<{ context?: string; attention: { entry?: Entry; disposition?: string } }>>;
 	/** Contexts the target node publishes for `execution: existing`. */
 	listReceiverContexts(nodeId: NodeId): Promise<ReceiverContext[]>;
 	resourceQuery?(meta: Record<string, Json>): Promise<ResourceReadQuery>;
+	/** Test seam: answers the judge's questions without a model. Production never sets it. */
+	judge?: (state: Row, questions: Questions) => Promise<Answers>;
 }
 
 const TODO_ENTRY = "mouriya.omp.todo-more";
@@ -139,6 +159,8 @@ const INBOUND_CONTEXT_CAP = 3;
 /** Threads and entries a target question scans for recent unanswered inbound messages. */
 const RECENT_INBOUND_THREADS = 3;
 const RECENT_INBOUND_PER_THREAD = 3;
+/** The O-2A candidate list is capped; the judge reads one line per candidate. */
+const REPLY_CANDIDATES = 5;
 /** Newest branch rows that may reach the trigger derivation; older work is history, not decision material. */
 const HISTORY_ROWS = 40;
 /** One row's text cap: a pasted terminal dump must not crowd out the rest of the state. */
@@ -180,13 +202,21 @@ export function fitState(state: Row): { fitted: Row; dropped: string[]; chars: n
 
 /** Decisions go through OMP's `judge` role; the plugin never picks a target or a plan itself. */
 export class JudgeDecider {
-	constructor(private readonly deps: DeciderDeps) {}
+	/** Deterministic reference resolution: one rule per reference, shared by every entry point. */
+	readonly refs: References;
+	private readonly guard: ActionGuard;
+
+	constructor(private readonly deps: DeciderDeps) {
+		this.refs = new References(this.deps);
+		this.guard = new ActionGuard({ contexts: deps.contexts, nodeId: deps.config.node.id });
+	}
 
 	async decide(scope: DecisionScope): Promise<Action> {
 		const explicit = await this.#explicit(scope);
 		if (explicit !== undefined) {
-			await this.#guard(scope, explicit);
-			return explicit;
+			const filled = await continueThread(this.deps, explicit);
+			await this.#allow(scope, filled);
+			return filled;
 		}
 
 		// A subagent classifies exactly as the main session does and `#guard` decides what may run.
@@ -194,7 +224,13 @@ export class JudgeDecider {
 		// asked for its own slice was told it had no rights at all (caerulea report 4, problem 1).
 		// Classification costs one local judge call; a write is refused either way.
 		const meta = scope.input.meta ?? {};
-		const intent = await this.#intent(scope);
+		const settlement = settleIntent(await this.#intent(scope), meta);
+		if (settlement.override !== undefined) {
+			// The judge named an intent whose fields the call does not carry. Naming the fallback
+			// in the record is what makes a misread visible instead of a silent rewrite.
+			this.deps.log?.("onlyne.judge.overridden", { direction: "outbound", ...settlement.override });
+		}
+		const intent = settlement.intent;
 		const action = intent === "communicate"
 			? await this.#communicate(scope, meta)
 			: intent === "inspect"
@@ -203,14 +239,28 @@ export class JudgeDecider {
 					? await this.#threadAction(scope, meta)
 					: intent === "manage_domain"
 						? await this.#domainAction(scope, meta)
-						: await this.#resourceAction(meta);
-		await this.#guard(scope, action);
-		this.deps.log?.("onlyne.judge.action", { direction: "outbound", ...actionFacts(action) });
-		return action;
+						: await resourceAction(meta);
+		const filled = await continueThread(this.deps, action);
+		await this.#allow(scope, filled);
+		this.deps.log?.("onlyne.judge.action", { direction: "outbound", ...actionFacts(filled) });
+		return filled;
+	}
+
+	/** The one guard every decided action passes before the client commits it. */
+	async #allow(scope: DecisionScope, action: Action): Promise<void> {
+		await this.guard.assert({ readOnly: scope.readOnly === true, agentId: scope.ctx.agent.id }, action);
 	}
 
-	/** Node O-1: one question, five options, no lists of peers, threads, or history. */
-	async #intent(scope: DecisionScope): Promise<"communicate" | "inspect" | "manage_thread" | "manage_domain" | "operate_resource"> {
+	/**
+	 * Node O-1: one question, only the options this call can execute, no lists of peers,
+	 * threads, or history.
+	 *
+	 * `operate_resource` is offered only when the call names a complete resource action. The
+	 * criterion that says a message mentioning a file is not this intent is still prose the
+	 * model may misread; withholding the option makes the misread unanswerable rather than
+	 * lethal (issue: outbound-intent-resource-false-positive).
+	 */
+	async #intent(scope: DecisionScope): Promise<OutboundIntent> {
 		const started = Date.now();
 		const answers = await this.#judge(
 			scope.ctx,
@@ -219,19 +269,7 @@ export class JudgeDecider {
 				trigger: this.#trigger(scope.ctx),
 				host_env: { session_type: scope.ctx.agent.kind, read_only: scope.readOnly === true },
 			},
-			{
-				intent: {
-					type: "choice",
-					instructions: text("judge.o1.instructions"),
-					criteria: {
-						communicate: text("judge.o1.communicate"),
-						inspect: text("judge.o1.inspect"),
-						manage_thread: text("judge.o1.manage_thread"),
-						manage_domain: text("judge.o1.manage_domain"),
-						operate_resource: text("judge.o1.operate_resource"),
-					},
-				},
-			},
+			intentQuestions({ resource: resourceFields(scope.input.meta) !== undefined }),
 			scope.signal,
 		);
 		const intent = choice(answers, "intent");
@@ -244,8 +282,20 @@ export class JudgeDecider {
 
 	/** Nodes O-2A / O-3A / O-3A-Ctx for a send, reply or followup. */
 	async #communicate(scope: DecisionScope, meta: Record<string, Json>): Promise<Action> {
-		const reply = await this.#reply(meta);
+		// Every reference this send names — recipient, thread, mentions, the message it answers —
+		// is resolved here, once, before the delivery plan is chosen. A plan built on a
+		// half-resolved reference is how the same spelling came to mean two things on two paths
+		// (audit §2.7).
+		const refs = await this.refs.forSend(meta);
+		let reply = refs.reply;
 		const explicitRelation = relation(meta);
+		if (reply === undefined && explicitRelation === undefined) {
+			// Node O-2A: no reference and no relation. The judge still answers one question —
+			// whether this call answers one of the inbound messages this context can see — and
+			// the plugin copies the exact ref from the record it names. Candidates are evidence
+			// for the question only: recency or being the sole pending message never binds one.
+			reply = await this.#originalQuestion(scope);
+		}
 		const lockedRelation = reply !== undefined
 			? explicitRelation ?? await this.#relationQuestion(scope, meta)
 			: undefined;
@@ -256,23 +306,21 @@ export class JudgeDecider {
 		if (reply !== undefined) {
 			// O-2A pre-pruning: the reply authority is the only target; meta.to and the judge's
 			// answer must not move a reply to another node (caerulea report 3).
-			const explicitTarget = await this.#target(meta);
-			if (explicitTarget !== undefined && explicitTarget !== reply.authority) {
+			if (refs.target !== undefined && refs.target !== reply.authority) {
 				throw new OnlyneError(
 					"invalid_request",
-					text("error.reply_authority", { authority: reply.authority, target: explicitTarget }),
+					text("error.reply_authority", { authority: reply.authority, target: refs.target }),
 				);
 			}
 			to = reply.authority;
 		} else {
-			to = await this.#target(meta) ?? await this.#targetQuestion(scope, meta);
+			to = refs.target ?? await this.#targetQuestion(scope, meta);
 			if (to.length === 0) {
 				throw new OnlyneError("ambiguous_target", text("error.delivery_target"));
 			}
 		}
 
 		const plan = await this.#deliveryPlan(scope, meta, lockedRelation, reply !== undefined);
-		const thread = await this.#sendThread(meta, to);
 		const context = plan.execution === "new" ? undefined : await this.#receiverContext(scope, to, meta);
 		if (plan.execution === "existing" && context === undefined) {
 			// RFC 0005 §1: `existing` disambiguates or refuses. Quietly opening a new context made
@@ -282,36 +330,123 @@ export class JudgeDecider {
 				text("error.execution_context_missing", { to }),
 			);
 		}
-		const mentions = await this.#mentions(meta);
-		return {
-			kind: "send",
+		return sendAction({
 			to,
-			...(thread === undefined ? {} : { thread }),
+			...(refs.thread === undefined ? {} : { thread: refs.thread }),
 			...(context === undefined ? {} : { context }),
-			...(reply === undefined ? {} : { in_reply_to: reply.ref }),
+			...(reply === undefined ? {} : { reply }),
 			...(lockedRelation === undefined ? {} : { relation: lockedRelation }),
-			...(mentions === undefined ? {} : { mentions }),
+			...(refs.mentions === undefined ? {} : { mentions: refs.mentions }),
 			response: plan.response,
 			execution: plan.execution,
+		});
+	}
+
+	/**
+	 * Node O-2A: the original this call answers. The judge chooses among the inbound records
+	 * this context can see and nobody has answered yet, plus `new_message`; the plugin copies
+	 * the exact MessageRef and the owner-attested reply authority from the record it names, so
+	 * no message id ever travels from the model to the wire.
+	 */
+	async #originalQuestion(scope: DecisionScope): Promise<ReplyReference | undefined> {
+		const candidates = await this.#replyCandidates(scope);
+		if (candidates.length === 0) return undefined;
+		const started = Date.now();
+		const keyOf = (index: number): string => `answer_${index + 1}`;
+		const facts = candidates.map((entry, index) => {
+			return {
+				key: keyOf(index),
+				from: entry.message.sender,
+				kind: entry.message.delivery_kind,
+				thread: threadKey(entry.thread_ref),
+				seq: entry.seq,
+				body: boundText(entry.message.msg),
+			};
+		});
+		const answers = await this.#judge(
+			scope.ctx,
+			{ focus: this.#focus(scope), trigger: this.#trigger(scope.ctx), candidates: facts },
+			originalQuestions(facts),
+			scope.signal,
+		);
+		this.#record("outbound.o2a_original", scope.input, answers, Date.now() - started);
+		const picked = choice(answers, "original");
+		if (picked === undefined || picked === "new_message") return undefined;
+		const entry = candidates[Number(picked.slice("answer_".length)) - 1];
+		if (entry === undefined) {
+			throw new OnlyneError("decision_unavailable", text("error.reply_relation"));
+		}
+		return {
+			ref: { sender: entry.message.sender, id: entry.message.id },
+			authority: entry.reply_authority,
+			thread_ref: entry.thread_ref,
 		};
 	}
 
+	/**
+	 * The inbound records this call can see and nobody has answered: rows delivered to this
+	 * session's context (the main session also sees rows no context claimed), minus the host's
+	 * handshake bookkeeping, minus entries a local reply already references. This set is what
+	 * O-2A offers the judge; it is never an answer by itself (RFC 0016 §7).
+	 */
+	async #replyCandidates(scope: DecisionScope): Promise<Entry[]> {
+		if (scope.readOnly === true) return [];
+		try {
+			const here = await this.#decisionContext(scope.ctx);
+			if (here === undefined) return [];
+			const rows = await this.deps.listInbox();
+			const candidates: Entry[] = [];
+			for (const row of rows) {
+				const entry = row.attention.entry;
+				if (entry === undefined || row.attention.disposition === "expired") continue;
+				if (entry.message.sender === this.deps.config.node.id) continue;
+				if (isTrustThread(this.deps.config.node.id, entry.thread_ref)) continue;
+				const deliveredHere = here.main
+					? row.context === undefined || row.context === "main"
+					: row.context === here.alias;
+				if (!deliveredHere) continue;
+				if (await this.#answered(entry)) continue;
+				candidates.push(entry);
+				if (candidates.length >= REPLY_CANDIDATES) break;
+			}
+			return candidates;
+		} catch (error) {
+			// A failed read narrows the question, not the decision: the call proceeds as a new message.
+			this.deps.log?.("onlyne.judge.hint_unavailable", { what: "reply_candidates", error: message(error) });
+			return [];
+		}
+	}
+
+	/** The context this session answers in: the main session, or a registered subagent context. */
+	async #decisionContext(ctx: ExtensionContext): Promise<{ alias?: string; main: boolean } | undefined> {
+		if (ctx.agent.id === this.deps.mainAgentId) return { main: true };
+		const record = (await this.deps.contexts.list()).find(row => row.agent_id === ctx.agent.id);
+		return record === undefined ? undefined : { alias: record.alias, main: false };
+	}
+
+	/** Whether this node already answered the entry in the thread that holds it. */
+	async #answered(entry: Entry): Promise<boolean> {
+		let cursor: string | undefined;
+		for (let page = 0; page < MAX_TAIL_PAGES; page++) {
+			const result = await this.deps.listMessages(entry.thread_ref, cursor);
+			for (const row of result.items) {
+				const ref = row.message.meta?.in_reply_to;
+				if (row.message.sender === this.deps.config.node.id && ref !== undefined
+					&& ref.sender === entry.message.sender && ref.id === entry.message.id) return true;
+			}
+			cursor = result.next_cursor ?? undefined;
+			if (cursor === undefined) return false;
+		}
+		return false;
+	}
+
 	/** Node O-2A question 1: the reply/followup/new relation, asked only when meta left it open. */
 	async #relationQuestion(scope: DecisionScope, meta: Record<string, Json>): Promise<"reply" | "followup"> {
 		const started = Date.now();
 		const answers = await this.#judge(
 			scope.ctx,
 			{ focus: this.#focus(scope), in_reply_to: meta.in_reply_to ?? null },
-			{
-				relation: {
-					type: "choice",
-					instructions: text("judge.relation.instructions"),
-					criteria: {
-						reply: text("judge.relation.reply"),
-						followup: text("judge.relation.followup"),
-					},
-				},
-			},
+			relationQuestions(),
 			scope.signal,
 		);
 		this.#record("outbound.o2a", scope.input, answers, Date.now() - started);
@@ -324,40 +459,25 @@ export class JudgeDecider {
 
 	/** Node O-2A question 2: the delivery target among live peers, asked only when meta.to is absent. */
 	async #targetQuestion(scope: DecisionScope, meta: Record<string, Json>): Promise<NodeId> {
-		const peers = await this.#peers();
-		if (!peers.available) {
-			throw new OnlyneError("unavailable", text("error.target_unresolved", { reason: peers.reason }));
-		}
-		// One discovered peer is the answer; none means the caller must name a target.
-		if (peers.value.length === 0) throw new OnlyneError("not_found", text("error.no_receiver"));
-		if (peers.value.length === 1) return peers.value[0]!.node_id;
+		// The same set `#peerId` resolves against: a peer this node holds a trust row with is a
+		// candidate even when discovery has nothing fresh to say about its address.
+		const peers = await knownPeers(this.deps);
+		// One known peer is the answer; none means the caller must name a target.
+		if (peers.length === 0) throw new OnlyneError("not_found", text("error.no_receiver"));
+		if (peers.length === 1) return peers[0]!.node_id;
 		const started = Date.now();
 		const answers = await this.#judge(
 			scope.ctx,
 			{
 				focus: { ...this.#focus(scope), meta_to: meta.to ?? null },
-				candidate_peers: peers.value.map(peer => ({
+				candidate_peers: peers.map(peer => ({
 					node_id: peer.node_id,
 					alias: lastSegment(peer.node_id),
 					last_seen: peer.last_seen,
 				})),
 				recent_inbound_unanswered: await this.#unanswered(scope.ctx),
 			},
-			{
-				target: {
-					type: "choice",
-					instructions: text("judge.target.instructions"),
-					criteria: Object.fromEntries(peers.value.map(peer => [
-						peer.node_id,
-						text("judge.target.peer", {
-							node: peer.node_id,
-							base_url: peer.base_url,
-							instance: peer.instance_id,
-							last_seen: peer.last_seen,
-						}),
-					])),
-				},
-			},
+			targetQuestions(peers),
 			scope.signal,
 		);
 		this.#record("outbound.o2a", scope.input, answers, Date.now() - started);
@@ -365,7 +485,7 @@ export class JudgeDecider {
 		if (chosen === undefined || chosen === "none") {
 			throw new OnlyneError("ambiguous_target", text("error.delivery_target"));
 		}
-		if (!peers.value.some(peer => peer.node_id === chosen)) {
+		if (!peers.some(peer => peer.node_id === chosen)) {
 			throw new OnlyneError("decision_unavailable", text("error.target_not_published", { chosen }));
 		}
 		return chosen;
@@ -378,63 +498,25 @@ export class JudgeDecider {
 		relation: "reply" | "followup" | undefined,
 		isReply: boolean,
 	): Promise<{ response: "await" | "async" | "none"; execution: "existing" | "new" }> {
-		const response = this.#inherited(meta, "response");
-		const execution = this.#inherited(meta, "execution");
-		if (response !== undefined && execution !== undefined) {
-			return { response: response as "await" | "async" | "none", execution: execution as "existing" | "new" };
+		const inherited = inheritedModes(meta);
+		// A plan the caller stated completely is not a question: asking it would offer to
+		// overrule the one party that knows what the call wants.
+		if (inherited.response !== undefined && inherited.execution !== undefined) {
+			return resolvedModes(inherited, {});
 		}
 		const started = Date.now();
 		const answers = await this.#judge(
 			scope.ctx,
 			{ focus: this.#focus(scope), relation: relation ?? "new" },
-			{
-				...(response === undefined
-					? {
-							response: {
-								type: "choice",
-								instructions: text("judge.response.instructions"),
-								criteria: {
-									none: text("judge.response.none"),
-									async: text("judge.response.async"),
-									await: text("judge.response.await"),
-								},
-							},
-						}
-					: {}),
-				...(execution === undefined
-					? {
-							execution: {
-								type: "choice",
-								instructions: text("judge.execution.instructions"),
-								criteria: {
-									existing: isReply
-										? text("judge.execution.existing.reply")
-										: text("judge.execution.existing.new"),
-									new: text("judge.execution.new"),
-								},
-							},
-						}
-					: {}),
-			},
+			planQuestions({
+				response: inherited.response === undefined,
+				execution: inherited.execution === undefined,
+				reply: isReply,
+			}),
 			scope.signal,
 		);
 		this.#record("outbound.o3a", scope.input, answers, Date.now() - started);
-		const chosenResponse = response ?? choice(answers, "response");
-		const chosenExecution = execution ?? choice(answers, "execution");
-		if (chosenResponse !== "none" && chosenResponse !== "async" && chosenResponse !== "await") {
-			throw new OnlyneError("decision_unavailable", text("error.response_mode"));
-		}
-		if (chosenExecution !== "existing" && chosenExecution !== "new") {
-			throw new OnlyneError("decision_unavailable", text("error.execution_mode"));
-		}
-		return { response: chosenResponse, execution: chosenExecution };
-	}
-
-	#inherited(meta: Record<string, Json>, key: string): "await" | "async" | "none" | "existing" | "new" | undefined {
-		const value = meta[key];
-		if (value === "await" || value === "async" || value === "none" || value === "existing" || value === "new") return value;
-		if (value !== undefined) throw new OnlyneError("invalid_request", text("error.meta_mode", { key }));
-		return undefined;
+		return resolvedModes(inherited, answers);
 	}
 
 	/**
@@ -465,19 +547,7 @@ export class JudgeDecider {
 		const answers = await this.#judge(
 			scope.ctx,
 			{ focus: this.#focus(scope), target_published_contexts: published },
-			{
-				context: {
-					type: "choice",
-					instructions: text("judge.context.instructions"),
-					criteria: {
-						...Object.fromEntries(published.map(context => [
-							context.alias,
-							text("judge.context.published", { summary: context.summary, state: context.state }),
-						])),
-						none: text("judge.context.none"),
-					},
-				},
-			},
+			contextQuestions(published),
 			scope.signal,
 		);
 		this.#record("outbound.o3a-ctx", scope.input, answers, Date.now() - started);
@@ -488,31 +558,6 @@ export class JudgeDecider {
 		return alias;
 	}
 
-	/**
-	 * The thread a send names. The thread decides where the message is stored; `to` decides who
-	 * is addressed. An initiator owns its thread for the whole conversation, so every member
-	 * writes into it and the client routes each message to that owner. A bare id that names no
-	 * local thread is the target's thread id, as a receipt reports it.
-	 */
-	async #sendThread(meta: Record<string, Json> | undefined, to: NodeId): Promise<ThreadRef | undefined> {
-		if (meta?.thread === undefined) return undefined;
-		const value = meta.thread;
-		if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-			return this.#thread(meta);
-		}
-		if (typeof value !== "string" || value.length === 0) {
-			throw new OnlyneError("invalid_request", text("error.thread_reference_shape"));
-		}
-		const matches = (await this.deps.listThreads()).filter(thread => thread.thread_ref.id === value || thread.title === value);
-		if (matches.length > 1) throw new OnlyneError("ambiguous_target", text("error.ambiguous_local_thread", { value }));
-		if (matches.length === 1) return matches[0]!.thread_ref;
-		const slash = value.indexOf("/");
-		if (slash > 0 && slash < value.length - 1) {
-			return { owner: value.slice(0, slash), id: value.slice(slash + 1) };
-		}
-		return { owner: to, id: value };
-	}
-
 	/**
 	 * One inbound entry's route. `plan` is the sender's delivery plan when the delivery named
 	 * one: an explicit `plan.context` is binding, `execution: new` is only a preference.
@@ -640,16 +685,7 @@ export class JudgeDecider {
 				current_work: this.#trigger(scope),
 				thread_dialogue: await this.#threadEvidenceFor([entry.thread_ref]),
 			},
-			{
-				needs_answer: {
-					type: "choice",
-					instructions: text("judge.needs_answer.instructions"),
-					criteria: {
-						yes: text("judge.needs_answer.yes"),
-						no: text("judge.needs_answer.no"),
-					},
-				},
-			},
+			needsAnswerQuestions(),
 			undefined,
 		);
 		this.#record("inbound.i0", { delivery_kind: entry.message.delivery_kind, msg: entry.message.msg, meta: entry.message.meta }, answers, Date.now() - started);
@@ -690,11 +726,6 @@ export class JudgeDecider {
 		const started = Date.now();
 		// `fragment` never starts a turn, so a message that needs an answer can never be one;
 		// offering it would be an option whose choice guarantees the obligation is missed.
-		const criteria: Record<string, string> = {
-			steer: text("judge.insertion.steer"),
-			follow_up: text("judge.insertion.follow_up"),
-			...(needsAnswer ? {} : { fragment: text("judge.insertion.fragment") }),
-		};
 		const answers = await this.#judge(
 			scope,
 			{
@@ -702,13 +733,7 @@ export class JudgeDecider {
 				host_running_state: { is_turn_active: !scope.isIdle(), plan_mode: this.#planActive(scope) },
 				urgency_signals: { has_stop_or_change: URGENCY_CUES.some(cue => body.includes(cue)) },
 			},
-			{
-				insertion_mode: {
-					type: "choice",
-					instructions: text("judge.insertion.instructions"),
-					criteria,
-				},
-			},
+			insertionQuestions({ fragment: !needsAnswer }),
 		);
 		this.#record("inbound.i2", { delivery_kind: entry.message.delivery_kind, msg: entry.message.msg, meta: entry.message.meta }, answers, Date.now() - started);
 		const mode = choice(answers, "insertion_mode");
@@ -833,6 +858,7 @@ export class JudgeDecider {
 				throw new OnlyneError("decision_unavailable", text("error.state_budget", { chars, cap: STATE_BUDGET_CHARS }));
 			}
 			if (dropped.length > 0) this.deps.log?.("onlyne.judge.trimmed", { dropped, chars });
+			if (this.deps.judge !== undefined) return await this.deps.judge(fitted as Row, questions);
 			const settings = (await Settings.current) ?? (await Settings.loadReadOnly({ cwd: scope.cwd }));
 			const judge = resolveJudge({
 				settings,
@@ -862,8 +888,9 @@ export class JudgeDecider {
 	}
 
 	/**
-	 * Only stable, explicit fields route without a decision. Everything semantic,
-	 * including a bare thread reference, goes to the judge.
+	 * Only stable, explicit fields route without a decision. A reference is resolved, never
+	 * judged: `meta.thread`, `meta.to` and `meta.resource` name a record, and whether the
+	 * message means to use them at all is what the judge answers.
 	 */
 	async #explicit(scope: DecisionScope): Promise<Action | undefined> {
 		const meta = scope.input.meta;
@@ -871,8 +898,8 @@ export class JudgeDecider {
 		if (meta.scope === "resources") return this.#read(scope, "resources");
 		const op = stringField(meta, "op");
 		if (op !== undefined && isThreadOp(op)) {
-			const thread = await this.#thread(meta);
-			const to = await this.#target(meta);
+			const thread = await this.refs.thread(meta);
+			const to = await this.refs.target(meta);
 			const title = stringField(meta, "title");
 			if (op === "create" && title === undefined) throw new OnlyneError("invalid_request", text("error.thread_title_required"));
 			if (op !== "create" && op !== "list" && thread === undefined) {
@@ -890,22 +917,7 @@ export class JudgeDecider {
 			};
 		}
 
-		const resource = recordField(meta, "resource");
-		if (resource !== undefined) {
-			const owner = stringField(resource, "owner");
-			const id = stringField(resource, "id");
-			const operation = stringField(meta, "operation");
-			if (owner === undefined || id === undefined || operation === undefined) {
-				throw new OnlyneError("invalid_request", text("error.resource_fields"));
-			}
-			return {
-				kind: "resource",
-				resource: { owner, id },
-				operation,
-				...(meta.data === undefined ? {} : { data: meta.data }),
-				...(typeof meta.expected_revision === "string" ? { expected_revision: meta.expected_revision } : {}),
-			};
-		}
+		if (recordField(meta, "resource") !== undefined) return resourceAction(meta);
 
 		const scopeName = stringField(meta, "scope");
 		if (scopeName !== undefined) {
@@ -925,7 +937,7 @@ export class JudgeDecider {
 			if (this.deps.resourceQuery === undefined) throw new OnlyneError("unavailable", text("error.resource_host_unavailable"));
 			return { kind: "read", scope: name, query: await this.deps.resourceQuery(meta) };
 		}
-		const thread = await this.#thread(meta);
+		const thread = await this.refs.thread(meta);
 		const page_size = pageSize(meta);
 		const cursor = stringField(meta, "cursor");
 		const seq = stringField(meta, "seq");
@@ -955,7 +967,7 @@ export class JudgeDecider {
 				attention: attention(meta),
 			};
 		}
-		const resolved = await this.#messageRef(meta, thread);
+		const resolved = await this.refs.message(meta, thread);
 		if (resolved === undefined) {
 			throw new OnlyneError("invalid_request", text("error.read_message_required", { name }));
 		}
@@ -976,20 +988,7 @@ export class JudgeDecider {
 		const answers = await this.#judge(
 			scope.ctx,
 			{ focus: { delivery_kind: scope.input.delivery_kind, msg: scope.input.msg, meta: meta ?? null } },
-			{
-				read_scope: {
-					type: "choice",
-					instructions: text("judge.read_scope.instructions"),
-					criteria: {
-						peers: text("judge.read_scope.peers"),
-						inbox: text("judge.read_scope.inbox"),
-						messages: text("judge.read_scope.messages"),
-						evidence: text("judge.read_scope.evidence"),
-						resources: text("judge.read_scope.resources"),
-						none: text("judge.read_scope.none"),
-					},
-				},
-			},
+			readScopeQuestions(),
 			scope.signal,
 		);
 		this.#record("outbound.o2b", scope.input, answers, Date.now() - started);
@@ -1005,7 +1004,7 @@ export class JudgeDecider {
 			throw new OnlyneError("decision_unavailable", text("error.read_scope_unknown", { scope: scopeName }));
 		}
 		const name: ActionReadScope = scopeName === "peers" ? "neighbors" : scopeName;
-		const thread = await this.#thread(meta);
+		const thread = await this.refs.thread(meta);
 		if (name === "messages") {
 			const chosen = thread ?? await this.#threadQuestion(scope, "outbound.o3b-th");
 			return {
@@ -1019,7 +1018,7 @@ export class JudgeDecider {
 			};
 		}
 		if (name === "evidence") {
-			const resolved = await this.#messageRef(meta, thread);
+			const resolved = await this.refs.message(meta, thread);
 			if (resolved === undefined) {
 				throw new OnlyneError("invalid_request", text("error.read_message_required", { name }));
 			}
@@ -1054,21 +1053,7 @@ export class JudgeDecider {
 					next_seq: thread.next_seq,
 				})),
 			},
-			{
-				thread: {
-					type: "choice",
-					instructions: text("judge.thread.instructions"),
-					criteria: Object.fromEntries(threads.map(thread => [
-						thread.thread_ref.id,
-						text("judge.thread.item", {
-							title: thread.title,
-							owner: thread.thread_ref.owner,
-							id: thread.thread_ref.id,
-							state: thread.state,
-						}),
-					])),
-				},
-			},
+			threadQuestions(threads.map(thread => ({ ref: thread.thread_ref, title: thread.title, state: thread.state }))),
 			scope.signal,
 		);
 		this.#record(node, scope.input, answers, Date.now() - started);
@@ -1076,7 +1061,7 @@ export class JudgeDecider {
 		if (alias === undefined || alias === "none") {
 			throw new OnlyneError("decision_unavailable", text("error.local_thread_choice"));
 		}
-		return this.#threadByAlias(alias);
+		return this.refs.threadByAlias(alias);
 	}
 
 	/** Node O-2C: the local thread operation. */
@@ -1085,20 +1070,7 @@ export class JudgeDecider {
 		const answers = await this.#judge(
 			scope.ctx,
 			{ focus: this.#focus(scope) },
-			{
-				thread_op: {
-					type: "choice",
-					instructions: text("judge.thread_op.instructions"),
-					criteria: {
-						create: text("judge.thread_op.create"),
-						close: text("judge.thread_op.close"),
-						list: text("judge.thread_op.list"),
-						describe: text("judge.thread_op.describe"),
-						member_add: text("judge.thread_op.member_add"),
-						member_remove: text("judge.thread_op.member_remove"),
-					},
-				},
-			},
+			threadOpQuestions(),
 			scope.signal,
 		);
 		this.#record("outbound.o2c", scope.input, answers, Date.now() - started);
@@ -1109,9 +1081,9 @@ export class JudgeDecider {
 		// A dependent second call: which thread the operation names is only decidable once the
 		// operation is known, and meta.thread settles it without a call (design §4, stepwise).
 		const thread = op === "create" || op === "list"
-			? await this.#thread(meta)
-			: await this.#thread(meta) ?? await this.#threadQuestion(scope, "outbound.o2c-thread");
-		const to = await this.#target(meta);
+			? await this.refs.thread(meta)
+			: await this.refs.thread(meta) ?? await this.#threadQuestion(scope, "outbound.o2c-thread");
+		const to = await this.refs.target(meta);
 		const title = stringField(meta, "title");
 		if ((op === "member_add" || op === "member_remove") && to === undefined) {
 			throw new OnlyneError("decision_unavailable", text("error.thread_op_target", { op }));
@@ -1134,20 +1106,7 @@ export class JudgeDecider {
 		const answers = await this.#judge(
 			scope.ctx,
 			{ focus: this.#focus(scope) },
-			{
-				domain_op: {
-					type: "choice",
-					instructions: text("judge.domain_op.instructions"),
-					criteria: {
-						create: text("judge.domain_op.create"),
-						join: text("judge.domain_op.join"),
-						leave: text("judge.domain_op.leave"),
-						list: text("judge.domain_op.list"),
-						describe: text("judge.domain_op.describe"),
-						discover: text("judge.domain_op.discover"),
-					},
-				},
-			},
+			domainOpQuestions(),
 			scope.signal,
 		);
 		this.#record("outbound.o2d", scope.input, answers, Date.now() - started);
@@ -1167,24 +1126,6 @@ export class JudgeDecider {
 		};
 	}
 
-	/** The resource branch carries no judge node: meta names every field. */
-	async #resourceAction(meta: Record<string, Json>): Promise<Action> {
-		const resource = recordField(meta, "resource");
-		const owner = resource === undefined ? undefined : stringField(resource, "owner");
-		const id = resource === undefined ? undefined : stringField(resource, "id");
-		const operation = stringField(meta, "operation");
-		if (owner === undefined || id === undefined || operation === undefined) {
-			throw new OnlyneError("invalid_request", text("error.resource_action_fields"));
-		}
-		return {
-			kind: "resource",
-			resource: { owner, id },
-			operation,
-			...(meta.data === undefined ? {} : { data: meta.data }),
-			...(typeof meta.expected_revision === "string" ? { expected_revision: meta.expected_revision } : {}),
-		};
-	}
-
 	/** The golden-triage head of every node state: what is being asked, verbatim. */
 	#focus(scope: DecisionScope): Row {
 		return {
@@ -1234,224 +1175,12 @@ export class JudgeDecider {
 	}
 
 
-	async #thread(meta: Record<string, Json> | undefined): Promise<ThreadRef | undefined> {
-		if (meta === undefined) return undefined;
-		const value = meta.thread;
-		if (value === undefined) return undefined;
-		if (typeof value === "string") return this.#threadByAlias(value);
-		const record = recordField(meta, "thread");
-		const owner = record === undefined ? undefined : stringField(record, "owner");
-		const id = record === undefined ? undefined : stringField(record, "id");
-		if (owner !== undefined && id !== undefined) return { owner, id };
-		throw new OnlyneError("invalid_request", text("error.thread_reference_shape"));
-	}
-
-	async #threadByAlias(alias: string): Promise<ThreadRef> {
-		const threads = await this.deps.listThreads();
-		const matches = threads.filter(thread => thread.thread_ref.id === alias || thread.title === alias);
-		if (matches.length === 1) return matches[0]!.thread_ref;
-		if (matches.length > 1) throw new OnlyneError("ambiguous_target", text("error.ambiguous_thread", { alias }));
-		if (alias.includes("/")) {
-			const [owner, id] = alias.split("/", 2);
-			if (owner !== undefined && id !== undefined && owner.length > 0 && id.length > 0) return { owner, id };
-		}
-		throw new OnlyneError("not_found", text("error.thread_not_found", { alias }));
-	}
-
-	async #target(meta: Record<string, Json> | undefined): Promise<NodeId | undefined> {
-		if (meta === undefined) return undefined;
-		const value = meta.to;
-		if (value === undefined) return undefined;
-		if (typeof value !== "string") {
-			throw new OnlyneError("invalid_request", text("error.meta_to_single"));
-		}
-		if (value.length === 0) throw new OnlyneError("invalid_request", text("error.meta_to_empty"));
-		return this.#peerId(value);
-	}
-
-	/**
-	 * Resolve an explicit target against live discovery. A bare alias is accepted
-	 * only when exactly one known node's last URN segment names it.
-	 */
-	async #peerId(alias: string): Promise<NodeId> {
-		const peers = await this.#peers();
-		if (!peers.available) {
-			throw new OnlyneError("unavailable", text("error.target_unresolved", { reason: peers.reason }));
-		}
-		const ids = [this.deps.config.node.id, ...peers.value.map(peer => peer.node_id)];
-		if (alias === "self") return this.deps.config.node.id;
-		if (ids.includes(alias)) return alias;
-		const matches = ids.filter(id => lastSegment(id) === alias);
-		if (matches.length === 1) return matches[0]!;
-		if (matches.length > 1) {
-			throw new OnlyneError("ambiguous_target", text("error.alias_ambiguous", { alias, matches: matches.join(", ") }));
-		}
-		throw new OnlyneError("not_found", text("error.alias_not_found", { alias }));
-	}
-
-	async #mentions(meta: Record<string, Json> | undefined): Promise<string[] | undefined> {
-		if (meta === undefined) return undefined;
-		const value = meta.mentions;
-		if (value === undefined) return undefined;
-		if (!Array.isArray(value)) throw new OnlyneError("invalid_request", text("error.mentions_array"));
-		const resolved: string[] = [];
-		for (const item of value) {
-			if (typeof item !== "string" || item.length === 0) {
-				throw new OnlyneError("invalid_request", text("error.mention_empty"));
-			}
-			if (item === "@all") {
-				resolved.push(item);
-				continue;
-			}
-			resolved.push(await this.#peerId(item.startsWith("@") ? item.slice(1) : item));
-		}
-		return resolved;
-	}
-
-	async #reply(meta: Record<string, Json> | undefined): Promise<{ ref: MessageRef; authority: NodeId; thread_ref?: ThreadRef } | undefined> {
-		if (meta === undefined) return undefined;
-		const value = meta.in_reply_to;
-		if (value === undefined) return undefined;
-		if (value === null || typeof value !== "object" || Array.isArray(value)) {
-			throw new OnlyneError("invalid_request", text("error.in_reply_to_object"));
-		}
-		const record = value as Record<string, Json>;
-		const sender = stringField(record, "sender");
-		const id = stringField(record, "id");
-		if (sender !== undefined && id !== undefined) {
-			// The authority is an identity, not the caller's spelling: `caerulea` and
-			// `urn:onlyne:agent:caerulea` name the same node, and the delivery target is always
-			// resolved. Comparing a raw string against a resolved id produced two contradictory
-			// errors in a row (cyanea report 1, problem 1).
-			const authority = await this.#peerId(sender).catch(() => sender);
-			return { ref: { sender, id }, authority };
-		}
-		const threadAlias = stringField(record, "thread");
-		const seq = seqField(record, "seq");
-		if (threadAlias === undefined) {
-			throw new OnlyneError("invalid_request", text("error.in_reply_to_shape"));
-		}
-		if (seq === undefined) {
-			throw new OnlyneError("invalid_request", text("error.in_reply_to_seq"));
-		}
-		const thread = await this.#threadByAlias(threadAlias);
-		const entry = await this.#entryAt(thread, seq);
-		if (entry === undefined) throw new OnlyneError("not_found", text("error.message_not_found", { thread: threadAlias, seq }));
-		return {
-			ref: { sender: entry.message.sender, id: entry.message.id },
-			authority: entry.reply_authority,
-			thread_ref: entry.thread_ref,
-		};
-	}
-
-	/**
-	 * The message a read names, with the thread it was resolved in. `{sender,id}` carries no
-	 * thread here; `{thread,seq}` does, and an explicit meta.thread that contradicts the
-	 * reference is refused rather than silently winning.
-	 */
-	async #messageRef(meta: Record<string, Json>, thread?: ThreadRef): Promise<{ ref: MessageRef; thread?: ThreadRef } | undefined> {
-		const value = meta.message;
-		const record = value !== null && typeof value === "object" && !Array.isArray(value)
-			? (value as Record<string, Json>)
-			: undefined;
-		const sender = record === undefined ? undefined : stringField(record, "sender");
-		const id = record === undefined ? undefined : stringField(record, "id");
-		if (sender !== undefined && id !== undefined) {
-			return { ref: { sender, id }, ...(thread === undefined ? {} : { thread }) };
-		}
-		// meta.message takes the same two shapes as meta.in_reply_to, including its own thread
-		// reference: `{thread, seq}` is the form a reader copies out of another reference, and
-		// refusing it while accepting `{sender, id}` made the same fact two spellings (caerulea 4).
-		const alias = record === undefined ? undefined : stringField(record, "thread");
-		const embedded = alias === undefined ? undefined : await this.#threadByAlias(alias);
-		if (thread !== undefined && embedded !== undefined && threadKey(thread) !== threadKey(embedded)) {
-			throw new OnlyneError(
-				"invalid_request",
-				text("error.message_thread_conflict", { thread: threadKey(thread), embedded: threadKey(embedded) }),
-			);
-		}
-		const scope = thread ?? embedded;
-		if (scope === undefined) return undefined;
-		const seq = (record === undefined ? undefined : seqField(record, "seq")) ?? seqField(meta, "seq");
-		if (seq === undefined) return undefined;
-		const entry = await this.#entryAt(scope, seq);
-		if (entry === undefined) throw new OnlyneError("not_found", text("error.message_not_found", { thread: scope.id, seq }));
-		return { ref: { sender: entry.message.sender, id: entry.message.id }, thread: scope };
-	}
-
-	async #entryAt(thread: ThreadRef, seq: string): Promise<Entry | undefined> {
-		let cursor: string | undefined;
-		for (let page = 0; page < MAX_TAIL_PAGES; page++) {
-			const result: Page<Entry> = await this.deps.listMessages(thread, cursor);
-			const found = result.items.find(entry => entry.seq === seq);
-			if (found !== undefined) return found;
-			cursor = result.next_cursor ?? undefined;
-			if (cursor === undefined) return undefined;
-		}
-		return undefined;
-	}
-
 	/**
-	 * A subagent may read only the threads its own context records authorize on
-	 * this node. The unfiltered node-wide views stay with the main session.
+	 * RFC 0018 §3.1: the node a mechanical `op` names, resolved against the same peer set a send
+	 * resolves `meta.to` from, so a name that addresses a peer once addresses it everywhere.
 	 */
-	async #guard(scope: DecisionScope, action: Action): Promise<void> {
-		if (scope.readOnly !== true) return;
-		if (action.kind !== "read") {
-			throw new OnlyneError(
-				"forbidden",
-				text("error.guard_write"),
-			);
-		}
-		if (action.scope === "resources") throw new OnlyneError("forbidden", text("error.resources_main_only"));
-		if (action.scope === "directory" || action.scope === "neighbors" || action.scope === "threads" || action.scope === "inbox") {
-			throw new OnlyneError(
-				"forbidden",
-				text("error.guard_node_listing"),
-			);
-		}
-		const records = await this.#authorizedRecords(scope.ctx.agent.id);
-		if (action.scope === "evidence") {
-			const ref = action.message;
-			const tied = ref !== undefined && records.some(record =>
-				record.source !== undefined && record.source.sender === ref.sender && record.source.id === ref.id,
-			);
-			if (!tied) {
-				throw new OnlyneError("forbidden", text("error.guard_evidence"));
-			}
-			return;
-		}
-		// `{sender,id}` names no thread, so the record that received that message is the
-		// authorization — the same tie evidence uses.
-		if (action.scope === "message" && action.thread === undefined && action.message !== undefined) {
-			const ref = action.message;
-			const tied = records.some(record =>
-				record.source !== undefined && record.source.sender === ref.sender && record.source.id === ref.id,
-			);
-			if (!tied) {
-				throw new OnlyneError("forbidden", text("error.guard_message"));
-			}
-			return;
-		}
-		if (action.thread === undefined) {
-			throw new OnlyneError("forbidden", text("error.guard_thread_required"));
-		}
-		const key = threadKey(action.thread);
-		if (!records.some(record => record.thread_ref !== undefined && threadKey(record.thread_ref) === key)) {
-			throw new OnlyneError("forbidden", text("error.guard_no_slice", { thread: key }));
-		}
-	}
-
-	async #authorizedRecords(agentId: string): Promise<ContextRecord[]> {
-		let records: ContextRecord[];
-		try {
-			records = await this.deps.contexts.list();
-		} catch (error) {
-			throw new OnlyneError("unavailable", text("error.registry_unreadable", { error: message(error) }));
-		}
-		return records.filter(record =>
-			record.node_id === this.deps.config.node.id && record.agent_id === agentId && record.thread_ref !== undefined,
-		);
+	async peerId(alias: string): Promise<NodeId> {
+		return this.refs.peerId(alias);
 	}
 
 	async #contextRows(): Promise<Source<Row[]>> {
@@ -1484,14 +1213,6 @@ export class JudgeDecider {
 	}
 
 
-	async #peers(): Promise<Source<PeerRecord[]>> {
-		try {
-			return ok(await this.deps.listPeers());
-		} catch (error) {
-			return none(text("reason.discovery_unreadable", { error: message(error) }));
-		}
-	}
-
 	async #receiverContexts(nodeId: NodeId): Promise<Source<ReceiverContext[]>> {
 		try {
 			return ok(await this.deps.listReceiverContexts(nodeId));
@@ -1624,12 +1345,6 @@ function actionFacts(action: Action): Record<string, string> {
 	return facts;
 }
 
-function choice(answers: Answers, key: string): string | undefined {
-	const answer = answers[key];
-	if (answer === undefined || answer === null || typeof answer !== "object") return undefined;
-	return typeof answer.choice === "string" ? answer.choice : undefined;
-}
-
 function stringField(record: Record<string, Json>, key: string): string | undefined {
 	const value = record[key];
 	return typeof value === "string" && value.length > 0 ? value : undefined;
@@ -1663,7 +1378,8 @@ function pageSize(meta: Record<string, Json>): number | undefined {
 
 function attention(meta: Record<string, Json>): "inbox" | "thread" {
 	const value = meta.attention;
-	if (value === undefined) return "thread";
+	// RFC 0005 §1: reads default to the attention list; `thread` is the switch that widens one.
+	if (value === undefined) return "inbox";
 	if (value === "inbox" || value === "thread") return value;
 	throw new OnlyneError("invalid_request", text("error.attention"));
 }
@@ -1684,10 +1400,6 @@ function branchOf(ctx: ExtensionContext): readonly SessionEntry[] {
 	return ctx.sessionManager.getBranch();
 }
 
-function threadKey(ref: ThreadRef): string {
-	return `${ref.owner}/${ref.id}`;
-}
-
 /**
  * A wording hint about whether the sender expects an answer: metadata says reply, or the body
  * greets or asks. It is evidence for node I-0, never the decision — a completed reply also
@@ -1700,13 +1412,6 @@ export function needsReplyOf(entry: Entry): boolean {
 	return REPLY_CUES.some(cue => body.includes(cue.toLowerCase())) || /\?|？|\bplease\b|期待/.test(entry.message.msg);
 }
 
-/** A node id's last URN segment; plain ids are their own segment. */
-function lastSegment(nodeId: NodeId): string {
-	const trimmed = nodeId.replace(/\/+$/, "");
-	const parts = trimmed.split(/[:/]/).filter(part => part.length > 0);
-	return parts.at(-1) ?? trimmed;
-}
-
 function entryFacts(entry: Entry): Row {
 	return {
 		thread_ref: entry.thread_ref,