omp-onlyne 0.2.0 → 0.3.0

package/src/drafts.ts

@@ -11,11 +11,17 @@ interface Draft {
 	prepared: PreparedSend;
 }
 
+/** How a caller names the draft it wants sent: by id, or by the message it answers. */
+export interface DraftRequest {
+	id?: string;
+	in_reply_to?: Json;
+}
+
 export async function createDraft(runtime: PluginRuntime, ctx: ExtensionContext, input: MsgInput, signal?: AbortSignal): Promise<unknown> {
 	const meta = { ...input.meta };
 	delete meta.op;
 	if (meta.relation !== "reply" && meta.relation !== "followup") throw new OnlyneError("invalid_request", t("draftNeedsRelation"));
-	const original = await resolveSource(runtime, meta.in_reply_to);
+	const original = await sourceReference(runtime, meta.in_reply_to);
 	if (ctx.agent.kind === "sub") {
 		const authorized = (await runtime.contexts.list()).some(record => record.agent_id === ctx.agent.id
 			&& record.source?.sender === original.sender && record.source.id === original.id);
@@ -30,28 +36,71 @@ export async function createDraft(runtime: PluginRuntime, ctx: ExtensionContext,
 		in_reply_to: original, body: prepared.message.msg, state: "draft", send: { meta: { draft_id: draft.id } } };
 }
 
-export async function sendDraft(runtime: PluginRuntime, ctx: ExtensionContext, id: string, signal?: AbortSignal): Promise<unknown> {
+/**
+ * Sends a prepared reply. The caller may name the draft by id or by the message it answers; a
+ * call that names neither continues with the most recent draft this session created, because
+ * the draft already carries the one decision that must not be taken twice — its plan.
+ */
+export async function sendDraft(runtime: PluginRuntime, ctx: ExtensionContext, request: DraftRequest, signal?: AbortSignal): Promise<unknown> {
 	if (ctx.agent.kind === "sub") throw new OnlyneError("forbidden", t("draftChildCannotSend"));
-	const draft = await runtime.storage.transaction(tx => tx.get<Draft>(`draft/${id}`));
-	if (draft === undefined) throw new OnlyneError("not_found", t("draftNotFound", { id }));
+	const draft = await findDraft(runtime, ctx, request);
 	const { to, message, plan } = draft.prepared;
 	return runtime.node.client.send(to, message, plan, { context: ctx.agent.id, signal });
 }
 
-async function resolveSource(runtime: PluginRuntime, value: Json | undefined): Promise<MessageRef> {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new OnlyneError("invalid_request", t("draftNeedsReference"));
-	if (typeof value.sender === "string" && typeof value.id === "string") return { sender: value.sender, id: value.id };
-	if (typeof value.thread === "string" && (typeof value.seq === "string" || typeof value.seq === "number")) {
-		const slash = value.thread.lastIndexOf("/");
-		const thread = slash < 0 ? { owner: runtime.config.node.id, id: value.thread }
-			: { owner: value.thread.slice(0, slash), id: value.thread.slice(slash + 1) };
-		let cursor: string | undefined;
-		do {
-			const result = await runtime.node.messages.list(runtime.node.auth, thread, { attention: "thread", page_size: 100, cursor });
-			const found = result.items.find(row => row.seq === String(value.seq));
-			if (found !== undefined) return { sender: found.message.sender, id: found.message.id };
-			cursor = result.next_cursor ?? undefined;
-		} while (cursor !== undefined);
+/**
+ * Draft lookup. The index is (created_by, in_reply_to): a reference names the draft that
+ * answered that message, and a session with no reference of its own sends the newest draft it
+ * created. Several drafts can answer one message — a child drafted, then the main session
+ * answered something else — so the newest wins; the draft's own plan is what makes the choice
+ * safe, since no wording is decided again here.
+ */
+async function findDraft(runtime: PluginRuntime, ctx: ExtensionContext, request: DraftRequest): Promise<Draft> {
+	if (request.id !== undefined) {
+		const draft = await runtime.storage.transaction(tx => tx.get<Draft>(`draft/${request.id}`));
+		if (draft === undefined) throw new OnlyneError("not_found", t("draftNotFound", { id: request.id }));
+		return draft;
+	}
+	// The store is the only index: drafts outlive the session that created them, and a scan of
+	// a handful of rows costs less than a second index that could disagree with it.
+	const stored = await runtime.storage.transaction(tx => tx.scan<Draft>("draft/"));
+	const drafts = stored.map(row => row.value);
+	const wanted = request.in_reply_to === undefined ? undefined : await sourceReference(runtime, request.in_reply_to);
+	const matching = wanted === undefined
+		? drafts
+		: drafts.filter(draft => {
+				const ref = draft.prepared.message.meta?.in_reply_to;
+				return ref !== undefined && ref.sender === wanted.sender && ref.id === wanted.id;
+			});
+	// This session's own draft is preferred; a child's draft it was just handed still answers,
+	// because the reference, not the author, is what the caller named.
+	const own = matching.filter(draft => draft.created_by === ctx.agent.id);
+	const pool = wanted === undefined ? own : own.length > 0 ? own : matching;
+	const newest = pool.sort((left, right) =>
+		right.created_at.localeCompare(left.created_at) || right.id.localeCompare(left.id))[0];
+	if (newest !== undefined) return newest;
+	throw wanted === undefined
+		? new OnlyneError("not_found", t("draftNoRecent"))
+		: new OnlyneError("not_found", t("draftNoMatch", { sender: wanted.sender, id: wanted.id }));
+}
+
+/** The message a draft answers, in the two shapes a caller can copy from a receipt or a read. */
+async function sourceReference(runtime: PluginRuntime, value: Json | undefined): Promise<MessageRef> {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		throw new OnlyneError("invalid_request", t("draftNeedsReference"));
+	}
+	const sender = typeof value.sender === "string" && value.sender.length > 0 ? value.sender : undefined;
+	const id = typeof value.id === "string" && value.id.length > 0 ? value.id : undefined;
+	if (sender !== undefined && id !== undefined) {
+		return { sender: await runtime.decider.refs.peerId(sender).catch(() => sender), id };
+	}
+	const thread = typeof value.thread === "string" && value.thread.length > 0 ? value.thread : undefined;
+	const seq = typeof value.seq === "number" ? String(value.seq) : typeof value.seq === "string" && value.seq.length > 0 ? value.seq : undefined;
+	if (thread !== undefined && seq !== undefined) {
+		const ref = await runtime.decider.refs.threadByAlias(thread);
+		const entry = await runtime.decider.refs.entryAt(ref, seq);
+		if (entry !== undefined) return { sender: entry.message.sender, id: entry.message.id };
+		throw new OnlyneError("not_found", t("draftSourceUnavailable"));
 	}
-	throw new OnlyneError("not_found", t("draftSourceUnavailable"));
+	throw new OnlyneError("invalid_request", t("draftNeedsReference"));
 }

package/src/guard.ts

@@ -0,0 +1,107 @@
+import { OnlyneError, type Action, type Json, type NodeId } from "@onlyne/lib";
+import type { ContextRegistry } from "@onlyne/node-host/store";
+import type { ContextRecord } from "@onlyne/node-host/types";
+import { text } from "./decider-text.ts";
+import { resourceFields } from "./plan.ts";
+import { threadKey } from "./resolve.ts";
+
+/** The five intents node O-1 chooses among. */
+export type OutboundIntent = "communicate" | "inspect" | "manage_thread" | "manage_domain" | "operate_resource";
+
+export interface IntentSettlement {
+	intent: OutboundIntent;
+	/** Set when a judged intent could not execute and a deterministic rule replaced it. */
+	override?: { chosen: OutboundIntent; fallback: OutboundIntent; reason: string };
+}
+
+/** A call that names a recipient: `meta.to`, or the message it answers. */
+function addressed(meta: Record<string, Json> | undefined): boolean {
+	if (meta === undefined) return false;
+	if (typeof meta.to === "string" && meta.to.length > 0) return true;
+	return meta.in_reply_to !== null && typeof meta.in_reply_to === "object" && !Array.isArray(meta.in_reply_to);
+}
+
+/**
+ * A resource intent is executable only when the fields it needs are present. The O-1 criteria
+ * already say a message that merely mentions a file is not a resource operation, but a criterion
+ * is prose the model may violate; this is the same rule in code.
+ *
+ * When a message names an explicit recipient and carries no complete resource action, the
+ * resource choice is a misread of a communication: letting it through can only fail on missing
+ * fields, and the error would send the caller to add `meta.resource` — turning a legitimate
+ * message into an operation on somebody's resource (issue: outbound-intent-resource-false-
+ * positive). With no recipient named the resource branch keeps its own hard error, because
+ * nothing in the call says the message was meant for anyone.
+ */
+export function settleIntent(intent: OutboundIntent, meta: Record<string, Json> | undefined): IntentSettlement {
+	if (intent !== "operate_resource") return { intent };
+	if (resourceFields(meta) !== undefined) return { intent };
+	if (!addressed(meta)) return { intent };
+	return {
+		intent: "communicate",
+		override: {
+			chosen: "operate_resource",
+			fallback: "communicate",
+			reason: "the message names a recipient and carries no complete meta.resource",
+		},
+	};
+}
+
+/**
+ * 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.
+ */
+export class ActionGuard {
+	constructor(private readonly deps: { contexts: ContextRegistry; nodeId: NodeId }) {}
+
+	async assert(scope: { readOnly?: boolean; agentId: string }, 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.authorized(scope.agentId);
+		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 }));
+		}
+	}
+
+	private async authorized(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: error instanceof Error ? error.message : String(error),
+			}));
+		}
+		return records.filter(record =>
+			record.node_id === this.deps.nodeId && record.agent_id === agentId && record.thread_ref !== undefined,
+		);
+	}
+}

package/src/handshake.ts

@@ -1,7 +1,7 @@
 import { OnlyneError, type Json, type KeyExchange, type Message, type NodeId, type Storage, type ThreadRef, type TrustEntry, type TrustPhase } from "@onlyne/lib";
-import { evaluateAcquisition, type AcquireInput, type AcquireVerdict, type AcquisitionPolicy } from "./acquire.ts";
+import { evaluateAcquisition, type AcquireInput, type AcquireVerdict, type AcquisitionPolicy } from "@onlyne/node-host/acquire";
 import { bridgeText as t } from "./bridge-text.ts";
-import { hostText } from "./host-text.ts";
+import { hostText } from "@onlyne/node-host/host-text";
 
 /**
  * RFC 0018 §3.2: the handshake entries live in one thread this node owns alone, so nothing in

package/src/messages.ts

@@ -1,10 +1,10 @@
-import { OnlyneError, type DeliveryPlan, type Entry, type Message, type NotifyEvent, type Runtime, type TraceEvent } from "@onlyne/lib";
+import { OnlyneError, type DeliveryPlan, type Entry, type Message, type NotifyEvent, type Runtime, type TraceEvent, type WorkRef } from "@onlyne/lib";
 import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { AgentRegistry } from "@oh-my-pi/pi-coding-agent/registry/agent-registry";
 import { refreshMailCards, renderMailMessage, type OnlyneMessageDetails } from "./ui/mail-message.ts";
 import type { InboundDecision, JudgeDecider } from "./decider.ts";
-import type { ContextRegistry } from "./store.ts";
-import type { ContextRecord } from "./types.ts";
+import type { ContextRegistry } from "@onlyne/node-host/store";
+import type { ContextRecord } from "@onlyne/node-host/types";
 import { AWAIT_CONSUMED, pendingAwaitResults } from "./tool.ts";
 import { applyMessageTodo, type TodoPlanner } from "./todo.ts";
 import { getRuntime } from "./runtime.ts";
@@ -96,8 +96,16 @@ export function createRuntimeBridge(deps: BridgeDeps): Runtime {
 			const fields = { ...event } as Record<string, unknown>;
 			const name = String(fields.event);
 			delete fields.event;
-			const thread = fields.thread as { owner?: unknown; id?: unknown } | undefined;
-			if (thread !== undefined) fields.thread = `${String(thread.owner)}/${String(thread.id)}`;
+			// `reconcile.failed` is the one event that names its thread as a bare id beside the
+			// owner, so formatting it as a reference logged `undefined/undefined` and dropped the
+			// id entirely. Every other event carries a real ThreadRef.
+			if (name === "reconcile.failed") {
+				fields.thread = `${String(fields.owner)}/${String(fields.thread)}`;
+				delete fields.owner;
+			} else {
+				const thread = fields.thread as { owner?: unknown; id?: unknown } | undefined;
+				if (thread !== undefined) fields.thread = `${String(thread.owner)}/${String(thread.id)}`;
+			}
 			if (TRACE_DEBUG.has(name)) deps.pi.logger.debug(`onlyne.${name}`, fields);
 			else deps.pi.logger.info(`onlyne.${name}`, fields);
 		},
@@ -414,6 +422,7 @@ function payload(entry: Entry, customType: string, token: string): MessagePayloa
 				from: entry.authenticated_author, at: entry.at, subject: entry.message.delivery_kind, body: entry.message.msg,
 				...(entry.message.meta?.relation === undefined ? {} : { relation: entry.message.meta.relation }),
 				...(entry.message.meta?.in_reply_to === undefined ? {} : { in_reply_to: entry.message.meta.in_reply_to }),
+				...(entry.message.meta?.work === undefined ? {} : { work: entry.message.meta.work }),
 			},
 		} };
 }
@@ -423,5 +432,14 @@ export function registerMessageRenderers(pi: ExtensionAPI): void {
 function renderEntry(entry: Entry, customType: string): string {
 	const label = customType === SUPPLEMENT ? t("labelSupplement") : t("labelInbound");
 	const relation = entry.message.meta?.relation === undefined ? "" : ` · ${entry.message.meta.relation}`;
-	return `${entry.thread_ref.id}/${entry.seq} · ${label} · ${entry.authenticated_author}${relation}\n${entry.message.msg.split(/\r?\n/).map(line => `  > ${line}`).join("\n")}`;
+	const work = workLabel(entry.message.meta?.work);
+	return `${entry.thread_ref.id}/${entry.seq} · ${label} · ${entry.authenticated_author}${relation}${work}\n${entry.message.msg.split(/\r?\n/).map(line => `  > ${line}`).join("\n")}`;
+}
+
+/** The work unit a sender named, so the receiver sees the dedupe key its answer belongs to. */
+export function workLabel(work: WorkRef | undefined): string {
+	if (work === undefined) return "";
+	const parent = work.parent === undefined || work.parent === null ? "" : ` · parent ${work.parent}`;
+	const attempt = work.attempt === undefined ? "" : ` · attempt ${work.attempt}`;
+	return ` · work ${work.unit}${parent}${attempt}`;
 }

package/src/plan.ts

@@ -0,0 +1,133 @@
+import { OnlyneError, type Action, type Json, type NodeId, type ThreadRef } from "@onlyne/lib";
+import { text } from "./decider-text.ts";
+import { choice, type Answers } from "./questions.ts";
+import { reuseThread, type ReplyReference, type ReferenceDeps } from "./resolve.ts";
+
+export type ResponseMode = "await" | "async" | "none";
+export type ExecutionMode = "existing" | "new";
+
+/** The plan fields the caller already fixed in meta. */
+export interface InheritedModes {
+	response?: ResponseMode;
+	execution?: ExecutionMode;
+}
+
+export interface ResourceFields {
+	owner: NodeId;
+	id: string;
+	operation: string;
+}
+
+function stringField(record: Record<string, Json>, key: string): string | undefined {
+	const value = record[key];
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function recordField(record: Record<string, Json>, key: string): Record<string, Json> | undefined {
+	const value = record[key];
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, Json>) : undefined;
+}
+
+/**
+ * A plan field the caller stated is binding and is never asked again; a value outside the two
+ * vocabularies is a caller error, never a reason to ask the judge. Anything the caller left out
+ * is decided by the O-3A question, which is why the omission is returned as `undefined` here
+ * rather than filled with a default (audit §2.5).
+ */
+export function inheritedModes(meta: Record<string, Json> | undefined): InheritedModes {
+	if (meta === undefined) return {};
+	const response = meta.response;
+	const execution = meta.execution;
+	if (response !== undefined && response !== "await" && response !== "async" && response !== "none") {
+		throw new OnlyneError("invalid_request", text("error.meta_mode", { key: "response" }));
+	}
+	if (execution !== undefined && execution !== "existing" && execution !== "new") {
+		throw new OnlyneError("invalid_request", text("error.meta_mode", { key: "execution" }));
+	}
+	return {
+		...(response === undefined ? {} : { response }),
+		...(execution === undefined ? {} : { execution }),
+	};
+}
+
+/** The complete plan: what the caller fixed, plus what the judge answered for the rest. */
+export function resolvedModes(inherited: InheritedModes, answers: Answers): { response: ResponseMode; execution: ExecutionMode } {
+	const response = inherited.response ?? choice(answers, "response");
+	const execution = inherited.execution ?? choice(answers, "execution");
+	if (response !== "none" && response !== "async" && response !== "await") {
+		throw new OnlyneError("decision_unavailable", text("error.response_mode"));
+	}
+	if (execution !== "existing" && execution !== "new") {
+		throw new OnlyneError("decision_unavailable", text("error.execution_mode"));
+	}
+	return { response, execution };
+}
+
+/**
+ * The fields a resource operation needs, or `undefined` when the call does not name a complete
+ * one. A partial `meta.resource` is not a resource action, and it is not a reason to fall back
+ * to communication either: the caller named a resource and must finish naming it.
+ */
+export function resourceFields(meta: Record<string, Json> | undefined): ResourceFields | undefined {
+	if (meta === undefined) return undefined;
+	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");
+	return owner === undefined || id === undefined || operation === undefined ? undefined : { owner, id, operation };
+}
+
+/** The resource action both the explicit and the judged branch build. */
+export function resourceAction(meta: Record<string, Json> | undefined): Action {
+	const fields = resourceFields(meta);
+	if (fields === undefined) throw new OnlyneError("invalid_request", text("error.resource_action_fields"));
+	const data = meta === undefined ? undefined : meta.data;
+	const revision = meta === undefined ? undefined : meta.expected_revision;
+	return {
+		kind: "resource",
+		resource: { owner: fields.owner, id: fields.id },
+		operation: fields.operation,
+		...(data === undefined ? {} : { data }),
+		...(typeof revision === "string" ? { expected_revision: revision } : {}),
+	};
+}
+
+/**
+ * The thread a send belongs to when the caller named none.
+ *
+ * A reply lands on the thread that holds its original (the client resolves it), and a plan
+ * that says `new` opens a topic. Otherwise the message continues the conversation this node
+ * already has with its addressee: leaving it unnamed makes the client open a thread per
+ * message, and asking the model for an alias it cannot know is the mistake the design already
+ * recorded. This is a lookup over local records, not a judgement (RFC 0016 §5).
+ */
+export async function continueThread(deps: ReferenceDeps, action: Action): Promise<Action> {
+	if (action.kind !== "send" || action.thread !== undefined) return action;
+	if (action.in_reply_to !== undefined || action.execution === "new") return action;
+	const thread = await reuseThread(deps, action.to);
+	return thread === undefined ? action : { ...action, thread };
+}
+
+/** One send action from its resolved references and judged plan. */
+export function sendAction(parts: {
+	to: NodeId;
+	response: "await" | "async" | "none";
+	execution: "existing" | "new";
+	thread?: ThreadRef;
+	context?: string;
+	reply?: ReplyReference;
+	relation?: "reply" | "followup";
+	mentions?: string[];
+}): Action {
+	return {
+		kind: "send",
+		to: parts.to,
+		...(parts.thread === undefined ? {} : { thread: parts.thread }),
+		...(parts.context === undefined ? {} : { context: parts.context }),
+		...(parts.reply === undefined ? {} : { in_reply_to: parts.reply.ref }),
+		...(parts.relation === undefined ? {} : { relation: parts.relation }),
+		...(parts.mentions === undefined ? {} : { mentions: parts.mentions }),
+		response: parts.response,
+		execution: parts.execution,
+	};
+}

package/src/questions.ts

@@ -0,0 +1,250 @@
+import type { NodeId, ThreadRef } from "@onlyne/lib";
+import { text } from "./decider-text.ts";
+import type { PeerRecord } from "./resolve.ts";
+
+/**
+ * The choice catalogs of the decision nodes. Each builder returns the question the judge
+ * answers, with only the options that can actually execute: an option whose choice is
+ * guaranteed to fail is a question the model cannot answer correctly.
+ */
+export interface ChoiceQuestion {
+	type: "choice";
+	instructions: string;
+	criteria: Record<string, string>;
+}
+
+export type Questions = Record<string, ChoiceQuestion>;
+
+export interface ChoiceAnswer {
+	type?: string;
+	choice?: string;
+}
+
+export type Answers = Record<string, ChoiceAnswer | undefined>;
+
+/** The one answer a choice question carries, or `undefined` when the judge gave none. */
+export 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;
+}
+
+/** Node O-1. `resource` is offered only when meta names a complete resource action. */
+export function intentQuestions(options: { resource: boolean }): Questions {
+	return {
+		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"),
+				...(options.resource ? { operate_resource: text("judge.o1.operate_resource") } : {}),
+			},
+		},
+	};
+}
+
+/** Node O-2A, question 1: the relation a reference carries. */
+export function relationQuestions(): Questions {
+	return {
+		relation: {
+			type: "choice",
+			instructions: text("judge.relation.instructions"),
+			criteria: {
+				reply: text("judge.relation.reply"),
+				followup: text("judge.relation.followup"),
+			},
+		},
+	};
+}
+
+/** Node O-3A: whichever of response and execution the caller left open. */
+export function planQuestions(open: { response: boolean; execution: boolean; reply: boolean }): Questions {
+	return {
+		...(open.response
+			? {
+					response: {
+						type: "choice" as const,
+						instructions: text("judge.response.instructions"),
+						criteria: {
+							none: text("judge.response.none"),
+							async: text("judge.response.async"),
+							await: text("judge.response.await"),
+						},
+					},
+				}
+			: {}),
+		...(open.execution
+			? {
+					execution: {
+						type: "choice" as const,
+						instructions: text("judge.execution.instructions"),
+						criteria: {
+							existing: open.reply
+								? text("judge.execution.existing.reply")
+								: text("judge.execution.existing.new"),
+							new: text("judge.execution.new"),
+						},
+					},
+				}
+			: {}),
+	};
+}
+
+/** Node O-3A-Ctx: which published context of the target continues the work. */
+export function contextQuestions(published: Array<{ alias: string; summary: string; state: string }>): Questions {
+	return {
+		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"),
+			},
+		},
+	};
+}
+
+/** Node O-2A, question 2: the recipient among the peers this node can name. */
+export function targetQuestions(peers: PeerRecord[]): Questions {
+	return {
+		target: {
+			type: "choice",
+			instructions: text("judge.target.instructions"),
+			criteria: {
+				// The abstain exit: an unnamed recipient must surface as ambiguous_target,
+				// never as a low-confidence random pick among peers.
+				none: text("judge.target.none"),
+				...Object.fromEntries(peers.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,
+					}),
+				])),
+			},
+		},
+	};
+}
+
+/** Node O-3B-Th: which local thread a read or thread operation names. */
+export function threadQuestions(threads: Array<{ ref: ThreadRef; title: string; state: string }>): Questions {
+	return {
+		thread: {
+			type: "choice",
+			instructions: text("judge.thread.instructions"),
+			criteria: Object.fromEntries(threads.map(thread => [
+				thread.ref.id,
+				text("judge.thread.item", {
+					title: thread.title,
+					owner: thread.ref.owner,
+					id: thread.ref.id,
+					state: thread.state,
+				}),
+			])),
+		},
+	};
+}
+
+/** Node O-2A: which unanswered inbound message this call answers, or none. */
+export function originalQuestions(
+	facts: Array<{ key: string; from: NodeId; kind: string; thread: string; seq: string; body: string }>,
+): Questions {
+	const criteria: Record<string, string> = { new_message: text("judge.original.new") };
+	for (const fact of facts) {
+		criteria[fact.key] = text("judge.original.candidate", {
+			from: fact.from, kind: fact.kind, thread: fact.thread, seq: fact.seq, body: fact.body,
+		});
+	}
+	return { original: { type: "choice", instructions: text("judge.original.instructions"), criteria } };
+}
+
+/** Node O-2B: which readable channel the message asks about. */
+export function readScopeQuestions(): Questions {
+	return {
+		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"),
+			},
+		},
+	};
+}
+
+/** Node O-2C: the local thread operation. */
+export function threadOpQuestions(): Questions {
+	return {
+		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"),
+			},
+		},
+	};
+}
+
+/** Node O-2D: the domain topology operation. */
+export function domainOpQuestions(): Questions {
+	return {
+		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"),
+			},
+		},
+	};
+}
+
+/** Node I-0: whether this node owes the sender an answer. */
+export function needsAnswerQuestions(): Questions {
+	return {
+		needs_answer: {
+			type: "choice",
+			instructions: text("judge.needs_answer.instructions"),
+			criteria: {
+				yes: text("judge.needs_answer.yes"),
+				no: text("judge.needs_answer.no"),
+			},
+		},
+	};
+}
+
+/** Node I-2: how a main-session delivery enters the agent's work. */
+export function insertionQuestions(options: { fragment: boolean }): Questions {
+	return {
+		insertion_mode: {
+			type: "choice",
+			instructions: text("judge.insertion.instructions"),
+			criteria: {
+				steer: text("judge.insertion.steer"),
+				follow_up: text("judge.insertion.follow_up"),
+				...(options.fragment ? { fragment: text("judge.insertion.fragment") } : {}),
+			},
+		},
+	};
+}