omp-onlyne 0.1.0 → 0.3.0

package/src/urls-text.ts

@@ -28,6 +28,8 @@ export const en = {
 	rootThreads: "Threads: {count}",
 	rootThreadRow: "- **{title}** `{key}` · {state} · next seq {next}",
 	rootNoThreads: "No threads.",
+	rootJoinedThreads: "Joined threads (read-only): {count}",
+	rootThreadJoinedRow: "- **{title}** `{key}` · read-only · last seq {last}",
 	rootViews: "Views: onlyne://neighbors, onlyne://threads, onlyne://inbox, onlyne://contexts, onlyne://outbound, onlyne://conversations",
 	rootViewsResources: "Views: onlyne://neighbors, onlyne://threads, onlyne://inbox, onlyne://contexts, onlyne://outbound, onlyne://conversations, onlyne://resources",
 	rootConversation: "Conversation: onlyne://conversations/<encoded-sender>/<encoded-id> · message: onlyne://messages/<encoded-sender>/<encoded-id>",
@@ -35,6 +37,9 @@ export const en = {
 
 	threadsTitle: "# Threads · {node}",
 	threadRow: "- **{title}** `{key}` · {state} · next seq {next} · {count} messages",
+	threadRowJoined: "- **{title}** `{key}` · read-only · last seq {last} · {count} messages",
+	threadJoinedLinks: "  thread {thread} · read-only, hosted by {owner}",
+	joinedThreadTitle: "Thread {id} (hosted by {owner})",
 	threadNoHistory: "  no local history yet · thread {url}",
 	threadLatest: "  latest {direction} · {at} · {snippet}",
 	threadLinks: "  thread {thread} · latest {latest} · conversation {conversation}",
@@ -44,6 +49,10 @@ export const en = {
 	noMessageAt: "No message at {key}/{seq}. onlyne:// lists the views.",
 	threadTitle: "# {title}",
 	threadMeta: "Thread `{key}` · {state} · next seq {next} · {count} messages",
+	threadReadOnly: "Read-only: `{owner}` hosts this thread; its state and members belong to the owner.",
+	threadStateUnknown: "state unknown",
+	ownerUnreachable: "the owner {owner} did not answer",
+	ownerHeld: "owner record",
 	members: "## Members",
 	memberRow: "- `{peer}` · {state} · {access}",
 	noAccess: "no access",
@@ -123,6 +132,9 @@ export const en = {
 	suffixReply: " · reply to {ref}",
 	suffixEntry: " · entry {url}",
 	suffixExpired: " · expired",
+	workLine: "  → work {unit}{parent}{attempt}",
+	workParent: " · parent {unit}",
+	workAttempt: " · attempt {attempt}",
 
 	resourcesTitle: "# Resources · {node}",
 	resourceOwnerError: "- unavailable: {code} · {message}",
@@ -167,6 +179,8 @@ export const zh: Record<keyof typeof en, string> = {
 	rootThreads: "线程：{count}",
 	rootThreadRow: "- **{title}** `{key}` · {state} · 下一序号 {next}",
 	rootNoThreads: "没有线程。",
+	rootJoinedThreads: "受邀线程（只读）：{count}",
+	rootThreadJoinedRow: "- **{title}** `{key}` · 只读 · 最后序号 {last}",
 	rootViews: "视图：onlyne://neighbors、onlyne://threads、onlyne://inbox、onlyne://contexts、onlyne://outbound、onlyne://conversations",
 	rootViewsResources: "视图：onlyne://neighbors、onlyne://threads、onlyne://inbox、onlyne://contexts、onlyne://outbound、onlyne://conversations、onlyne://resources",
 	rootConversation: "对话：onlyne://conversations/<encoded-sender>/<encoded-id> · 消息：onlyne://messages/<encoded-sender>/<encoded-id>",
@@ -174,6 +188,9 @@ export const zh: Record<keyof typeof en, string> = {
 
 	threadsTitle: "# 线程 · {node}",
 	threadRow: "- **{title}** `{key}` · {state} · 下一序号 {next} · {count} 条消息",
+	threadRowJoined: "- **{title}** `{key}` · 只读 · 最后序号 {last} · {count} 条消息",
+	threadJoinedLinks: "  线程 {thread} · 只读，由 {owner} 托管",
+	joinedThreadTitle: "线程 {id}（由 {owner} 托管）",
 	threadNoHistory: "  尚无本地历史 · 线程 {url}",
 	threadLatest: "  最新 {direction} · {at} · {snippet}",
 	threadLinks: "  线程 {thread} · 最新 {latest} · 对话 {conversation}",
@@ -183,6 +200,10 @@ export const zh: Record<keyof typeof en, string> = {
 	noMessageAt: "{key}/{seq} 处没有消息。onlyne:// 列出了所有视图。",
 	threadTitle: "# {title}",
 	threadMeta: "线程 `{key}` · {state} · 下一序号 {next} · {count} 条消息",
+	threadReadOnly: "只读：该线程由 `{owner}` 托管，状态与成员属于所有者。",
+	threadStateUnknown: "状态未知",
+	ownerUnreachable: "所有者 {owner} 没有应答",
+	ownerHeld: "所有者记录",
 	members: "## 成员",
 	memberRow: "- `{peer}` · {state} · {access}",
 	noAccess: "无访问权限",
@@ -262,6 +283,9 @@ export const zh: Record<keyof typeof en, string> = {
 	suffixReply: " · 回复 {ref}",
 	suffixEntry: " · 条目 {url}",
 	suffixExpired: " · 已过期",
+	workLine: "  → 工作单元 {unit}{parent}{attempt}",
+	workParent: " · 父单元 {unit}",
+	workAttempt: " · 第 {attempt} 次",
 
 	resourcesTitle: "# 资源 · {node}",
 	resourceOwnerError: "- 不可用：{code} · {message}",

package/src/urls.ts

@@ -5,6 +5,7 @@ import {
 	type Entry,
 	type HistoryMessage,
 	type HistoryQuery,
+	type JoinedThread,
 	type LocalAttention,
 	type MessageRef,
 	type OperationRecord,
@@ -15,8 +16,10 @@ import {
 	type ResourceInventory,
 	type ResourceRef,
 	type Thread,
+	type ThreadDescription,
 	type ThreadRef,
 	type TrustPhase,
+	type WorkRef,
 } from "@onlyne/lib";
 import { createTranslator } from "@onlyne/node-host/i18n";
 import {
@@ -29,7 +32,8 @@ import {
 } from "@oh-my-pi/pi-coding-agent/internal-urls";
 import { resourceQuery } from "./resources.ts";
 import { getRuntime, type PluginRuntime } from "./runtime.ts";
-import type { ContextRecord } from "./types.ts";
+import { isTrustThread, trustThread } from "./handshake.ts";
+import type { ContextRecord } from "@onlyne/node-host/types";
 import { urlsText } from "./urls-text.ts";
 
 type Caller = { main: boolean; agent_id?: string };
@@ -50,13 +54,15 @@ const TITLE_CHARS = 80;
 
 const handler: ProtocolHandler = {
 	scheme: "onlyne",
-	spec: { backing: "virtual", selectors: "lines", immutable: true },
+	// Every view reads live node state: threads, inbox, neighbors and conversations change
+	// between two reads of the same URL, so OMP must never serve a cached copy.
+	spec: { backing: "virtual", selectors: "lines", immutable: false },
 
 	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
 		const runtime = getRuntime();
 		if (runtime === undefined) throw new Error(t("notConfigured"));
 		const rendered = await render(runtime, callerOf(runtime, context), viewOf(url));
-		return { url: url.href, content: rendered.content, contentType: rendered.contentType, immutable: true };
+		return { url: url.href, content: rendered.content, contentType: rendered.contentType };
 	},
 
 	/**
@@ -79,10 +85,16 @@ const handler: ProtocolHandler = {
 			for (const thread of await visibleThreads(runtime, caller)) {
 				urls.push(threadPath(thread.thread_ref));
 			}
+			for (const row of await joinedThreads(runtime, caller)) {
+				urls.push(threadPath(row.thread_ref));
+			}
 			return leafDocuments(runtime, caller, urls);
 		}
 		if (view.host === "threads" && view.parts.length === 0) {
-			const urls = (await visibleThreads(runtime, caller)).map(thread => threadPath(thread.thread_ref));
+			const urls = [
+				...(await visibleThreads(runtime, caller)).map(thread => threadPath(thread.thread_ref)),
+				...(await joinedThreads(runtime, caller)).map(row => threadPath(row.thread_ref)),
+			];
 			return leafDocuments(runtime, caller, urls);
 		}
 		if (view.host === "threads") {
@@ -92,7 +104,7 @@ const handler: ProtocolHandler = {
 				const entry = await entryAt(runtime, thread, target.seq);
 				return [{ url: entryPath(thread.thread_ref, target.seq), content: `${JSON.stringify(entry, null, 2)}\n` }];
 			}
-			const entries = await allMessages(runtime, thread.thread_ref);
+			const entries = await threadEntries(runtime, thread.thread_ref);
 			return entries.map(entry => ({
 				url: entryPath(thread.thread_ref, entry.seq),
 				content: JSON.stringify(entry, null, 2),
@@ -233,6 +245,7 @@ async function renderRoot(runtime: PluginRuntime, caller: Caller): Promise<strin
 	}
 	const records = await scopedRecords(runtime, caller);
 	const threads = await visibleThreads(runtime, caller);
+	const joined = await joinedThreads(runtime, caller);
 	lines.push("", caller.main
 		? t("rootContexts", { count: records.length })
 		: t("rootContextsHeld", { agent: caller.agent_id ?? "", count: records.length }));
@@ -251,6 +264,16 @@ async function renderRoot(runtime: PluginRuntime, caller: Caller): Promise<strin
 		}));
 	}
 	if (threads.length === 0) lines.push(t("rootNoThreads"));
+	if (joined.length > 0) {
+		lines.push("", t("rootJoinedThreads", { count: joined.length }));
+		for (const row of joined) {
+			lines.push(t("rootThreadJoinedRow", {
+				title: row.title ?? t("joinedThreadTitle", { id: row.thread_ref.id, owner: row.thread_ref.owner }),
+				key: threadKey(row.thread_ref),
+				last: row.last_seq,
+			}));
+		}
+	}
 	lines.push(
 		"",
 		caller.main ? t("rootViewsResources") : t("rootViews"),
@@ -264,13 +287,30 @@ async function renderThreads(runtime: PluginRuntime, caller: Caller, view: View)
 	requireSession(caller, "threads");
 	if (view.parts.length === 0) {
 		const request = pageRequest(view);
-		const threads = (await visibleThreads(runtime, caller))
-			.slice()
-			.sort((left, right) => threadKey(left.thread_ref).localeCompare(threadKey(right.thread_ref)));
+		// One list of everything this node can read: a joined row is marked read-only and
+		// carries only what the local records prove, because its owner holds the rest. The
+		// merged order is the cursor's order, so it is sorted after the two sources join.
+		const threads: Array<Thread | JoinedThread> = [
+			...(await visibleThreads(runtime, caller)),
+			...(await joinedThreads(runtime, caller)),
+		].sort((left, right) => threadKey(left.thread_ref).localeCompare(threadKey(right.thread_ref)));
 		const index = await historyIndex(runtime, caller);
 		const page = localPage(threads, request, cursorScope("threads", caller, ""), thread => threadKey(thread.thread_ref));
 		const lines = [t("threadsTitle", { node: runtime.config.node.id }), ""];
 		for (const thread of page.items) {
+			if ("read_only" in thread) {
+				lines.push(t("threadRowJoined", {
+					title: thread.title ?? t("joinedThreadTitle", { id: thread.thread_ref.id, owner: thread.thread_ref.owner }),
+					key: threadKey(thread.thread_ref),
+					last: thread.last_seq,
+					count: thread.message_count,
+				}));
+				lines.push(t("threadJoinedLinks", {
+					thread: threadPath(thread.thread_ref),
+					owner: thread.thread_ref.owner,
+				}));
+				continue;
+			}
 			const rows = index.get(threadKey(thread.thread_ref)) ?? [];
 			const first = rows[0];
 			const latest = rows.at(-1);
@@ -327,34 +367,54 @@ function threadTarget(parts: string[]): ThreadTarget {
 	return { alias: parts.join("/") };
 }
 
-async function entryAt(runtime: PluginRuntime, thread: Thread, seq: string): Promise<Entry> {
-	const entry = (await allMessages(runtime, thread.thread_ref)).find(item => item.seq === seq);
+async function entryAt(runtime: PluginRuntime, thread: Thread | JoinedThread, seq: string): Promise<Entry> {
+	const entry = (await threadEntries(runtime, thread.thread_ref)).find(item => item.seq === seq);
 	if (entry === undefined) throw new Error(t("noMessageAt", { key: threadKey(thread.thread_ref), seq }));
 	return entry;
 }
 
-async function messageView(runtime: PluginRuntime, thread: Thread, seq: string): Promise<Rendered> {
+async function messageView(runtime: PluginRuntime, thread: Thread | JoinedThread, seq: string): Promise<Rendered> {
 	return json(await entryAt(runtime, thread, seq));
 }
 
-async function renderThread(runtime: PluginRuntime, thread: Thread): Promise<string> {
-	const rows = await threadMessages(runtime, thread.thread_ref);
-	const title = rows.length === 0 ? thread.title : titleOf(rows[0]!);
+/**
+ * One thread document. A hosted thread is rendered from this node's history projection; a
+ * joined one is read from its owner, and the page says so: the owner holds the state, the
+ * member table and the entries, and nothing here claims to change them.
+ */
+async function renderThread(runtime: PluginRuntime, thread: Thread | JoinedThread): Promise<string> {
+	const joined = "read_only" in thread;
+	const ref = thread.thread_ref;
+	const rows = joined ? [] : await threadMessages(runtime, ref);
+	const entries = joined ? await threadEntries(runtime, ref) : [];
+	let described: ThreadDescription | undefined;
+	try {
+		described = await runtime.node.client.describeThread(ref);
+	} catch {
+		// The owner's answer is what a joined page is mostly about, so its absence is stated
+		// below rather than papered over with local guesses.
+		described = undefined;
+	}
+	const title = thread.title ?? (rows.length === 0 ? ref.id : titleOf(rows[0]!));
+	const next = described?.thread.next_seq ?? ("next_seq" in thread ? thread.next_seq : thread.last_seq);
+	const count = joined ? entries.length : rows.length;
 	const lines = [
 		t("threadTitle", { title }),
 		"",
 		t("threadMeta", {
-			key: threadKey(thread.thread_ref),
-			state: thread.state,
-			next: thread.next_seq,
-			count: rows.length,
+			key: threadKey(ref),
+			state: described?.thread.state ?? thread.state ?? t("threadStateUnknown"),
+			next,
+			count,
 		}),
-		"",
-		t("members"),
-		"",
 	];
-	try {
-		const described = await runtime.node.threads.describe(runtime.node.auth, thread.thread_ref);
+	if (joined) lines.push("", t("threadReadOnly", { owner: ref.owner }));
+	lines.push("", t("members"), "");
+	if (described === undefined) {
+		lines.push(t("unavailable", { message: t("ownerUnreachable", { owner: ref.owner }) }));
+	} else if (described.members.length === 0) {
+		lines.push(t("noMembers"));
+	} else {
 		for (const member of described.members) {
 			lines.push(t("memberRow", {
 				peer: member.peer,
@@ -362,13 +422,11 @@ async function renderThread(runtime: PluginRuntime, thread: Thread): Promise<str
 				access: member.access.length === 0 ? t("noAccess") : member.access.join(", "),
 			}));
 		}
-		if (described.members.length === 0) lines.push(t("noMembers"));
-	} catch (error) {
-		lines.push(t("unavailable", { message: error instanceof Error ? error.message : String(error) }));
 	}
 	lines.push("", t("messages"), "");
-	for (const row of rows) lines.push(renderHistoryRow(row, runtime.config.node.id));
-	if (rows.length === 0) lines.push(t("noMessages"));
+	if (joined) for (const entry of entries) lines.push(renderEntryRow(entry, runtime.config.node.id));
+	else for (const row of rows) lines.push(renderHistoryRow(row, runtime.config.node.id));
+	if (count === 0) lines.push(t("noMessages"));
 	return `${lines.join("\n")}\n`;
 }
 
@@ -420,11 +478,23 @@ export async function neighborRows(runtime: PluginRuntime): Promise<NeighborRow[
 			base_url: record.base_url,
 			...(record.membership?.domain_id === undefined ? {} : { region: record.membership.domain_id }),
 			...(record.last_seen === undefined ? {} : { last_seen: record.last_seen }),
-			verified,
+			verified: verified || entry?.state === "trusted",
 			phase: entry === undefined ? "no_exchange" : trustPhase(entry),
 			fingerprint: entry?.fingerprint ?? null,
 		});
 	}
+	// A trust row outlives a discovery record: a peer paired earlier is still a neighbor
+	// before mDNS or a seed refresh brings it back, and the listing says so.
+	for (const entry of trust.values()) {
+		if (entry.node_id === runtime.config.node.id || byNode.has(entry.node_id)) continue;
+		byNode.set(entry.node_id, {
+			node_id: entry.node_id,
+			base_url: entry.base_url,
+			verified: entry.state === "trusted",
+			phase: trustPhase(entry),
+			fingerprint: entry.fingerprint,
+		});
+	}
 	return [...byNode.values()].sort((left, right) => left.node_id.localeCompare(right.node_id));
 }
 
@@ -532,6 +602,7 @@ function outboundRow(outbound: Outbound): { position: string; lines: string[] }
 	const at = outbound.created_at ?? null;
 	const status = [outbound.state, outbound.error?.code ?? ""].filter(part => part.length > 0).join(" · ");
 	const reply = related === undefined ? "" : t("suffixReply", { ref: `${related.sender}/${related.id}` });
+	const work = workText(message.meta?.work);
 	const position = `${at ?? ""}\u0000${refKey(ref)}`;
 	const lines = [
 		t("outboundRow", {
@@ -541,6 +612,7 @@ function outboundRow(outbound: Outbound): { position: string; lines: string[] }
 			status,
 			reply,
 		}),
+		...(work === undefined ? [] : [work]),
 		`  ${firstLine(message.msg, SNIPPET_CHARS)}`,
 		t("outboundLinks", { message: messagePath(ref), conversation: conversationPath(ref) }),
 	];
@@ -732,7 +804,7 @@ async function inboxLeaves(runtime: PluginRuntime, caller: Caller): Promise<Arra
 	}
 	const leaves: Array<{ url: string; content: string }> = [];
 	for (const group of byThread.values()) {
-		const entries = await allMessages(runtime, group.ref);
+		const entries = await threadEntries(runtime, group.ref);
 		for (const entry of entries) {
 			if (!group.seqs.has(entry.seq)) continue;
 			leaves.push({
@@ -758,19 +830,38 @@ async function visibleThreads(runtime: PluginRuntime, caller: Caller): Promise<T
 	return threads.filter(thread => allowed.has(threadKey(thread.thread_ref)));
 }
 
-async function findThread(runtime: PluginRuntime, caller: Caller, alias: string): Promise<Thread> {
+async function findThread(runtime: PluginRuntime, caller: Caller, alias: string): Promise<Thread | JoinedThread> {
 	const threads = await visibleThreads(runtime, caller);
-	const matches = threads.filter(thread =>
+	const matches: Array<Thread | JoinedThread> = threads.filter(thread =>
 		thread.thread_ref.id === alias ||
 		thread.title === alias ||
 		threadKey(thread.thread_ref) === alias,
 	);
+	// A thread this node was invited into is named the same way, but its record lives on the
+	// owner: the id and the `owner/id` key are what the local records can answer for.
+	for (const row of await joinedThreads(runtime, caller)) {
+		if (row.thread_ref.id === alias || row.title === alias || threadKey(row.thread_ref) === alias) matches.push(row);
+	}
 	if (matches.length === 1) return matches[0]!;
 	if (matches.length > 1) throw new Error(t("manyThreadsNamed", { alias }));
+	// RFC 0018 §3.2 keeps the handshake thread out of the conversation listings. An inbox row
+	// for a handshake entry still links straight to it, and a link that opens nothing is worse
+	// than a listing nobody needs: a reference that names it exactly resolves here.
+	const direct = caller.main ? await trustThreadNamed(runtime, alias) : undefined;
+	if (direct !== undefined) return direct;
 	if (!caller.main && caller.agent_id !== undefined) throw new Error(t("noThreadSlice", { alias }));
 	throw new Error(t("noThreadNamed", { alias }));
 }
 
+/** The handshake thread, when the alias names it exactly; the listings never offer it. */
+async function trustThreadNamed(runtime: PluginRuntime, alias: string): Promise<Thread | undefined> {
+	const ref = trustThread(runtime.config.node.id);
+	const names = new Set([ref.id, threadKey(ref), `${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.id)}`]);
+	if (!names.has(alias)) return undefined;
+	const described = await runtime.node.threads.describe(runtime.node.auth, ref).catch(() => undefined);
+	return described?.thread;
+}
+
 /** Contexts this caller may see: every node-local record for the main session, its own records otherwise. */
 async function scopedRecords(runtime: PluginRuntime, caller: Caller): Promise<ContextRecord[]> {
 	const records = (await runtime.contexts.list()).filter(record => record.node_id === runtime.config.node.id);
@@ -811,12 +902,32 @@ function conversationPermitted(conversation: Conversation, allowed: Set<string>,
 }
 
 async function localThreads(runtime: PluginRuntime): Promise<Thread[]> {
-	return collect(cursor =>
+	// RFC 0018 §3.2: the handshake thread is this host's own record, not a conversation.
+	const threads = await collect(cursor =>
 		runtime.node.threads.list(runtime.node.auth, {
 			page_size: PAGE,
 			...(cursor === undefined ? {} : { cursor }),
 		}),
 	);
+	return threads.filter(thread => !isTrustThread(runtime.config.node.id, thread.thread_ref));
+}
+
+/**
+ * Threads this node was invited into. They live on their owner, so the rows carry only what
+ * the local records prove; the owner is asked for the title and the member table where the
+ * detail page needs them. A subagent sees the joined threads its own records name.
+ */
+async function joinedThreads(runtime: PluginRuntime, caller: Caller): Promise<JoinedThread[]> {
+	const rows = await collect(cursor =>
+		runtime.node.threads.joined(runtime.node.auth, {
+			page_size: PAGE,
+			...(cursor === undefined ? {} : { cursor }),
+		}),
+	);
+	const visible = rows.filter(row => !isTrustThread(runtime.config.node.id, row.thread_ref));
+	if (caller.main) return visible;
+	const allowed = allowedThreads(await scopedRecords(runtime, caller));
+	return visible.filter(row => allowed.has(threadKey(row.thread_ref)));
 }
 
 async function allMessages(runtime: PluginRuntime, ref: Thread["thread_ref"]): Promise<Entry[]> {
@@ -829,6 +940,22 @@ async function allMessages(runtime: PluginRuntime, ref: Thread["thread_ref"]): P
 	);
 }
 
+/**
+ * A thread's entries: this node's own storage for a thread it hosts, the owner's message
+ * route otherwise. A member holds no copy of a joined thread's entries, so the owner is the
+ * only source that can answer for them.
+ */
+async function threadEntries(runtime: PluginRuntime, ref: ThreadRef): Promise<Entry[]> {
+	if (ref.owner === runtime.config.node.id) return allMessages(runtime, ref);
+	return collect(cursor =>
+		runtime.node.client.threadEntries(ref, {
+			attention: "thread",
+			page_size: PAGE,
+			...(cursor === undefined ? {} : { cursor }),
+		}),
+	);
+}
+
 /** The node's own outbound records; a subagent sees only replies tied to a message it received. */
 async function outboundRows(runtime: PluginRuntime, caller: Caller): Promise<Outbound[]> {
 	const rows = await runtime.storage.transaction(tx => tx.scan<Outbound>("outbound/"));
@@ -1316,6 +1443,39 @@ function entryPath(ref: ThreadRef, seq: string): string {
 	return `onlyne://threads/${encodeURIComponent(ref.id)}/messages/${encodeURIComponent(seq)}`;
 }
 
+/** The entry route of a thread named by its full `owner/id` key, which a joined thread needs. */
+function ownedEntryPath(ref: ThreadRef, seq: string): string {
+	return `onlyne://threads/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.id)}/messages/${encodeURIComponent(seq)}`;
+}
+
+/**
+ * One entry as its owner holds it. A joined thread's page is the owner's record, so it reports
+ * the entry itself and never claims this node's own delivery or consumption state for it.
+ */
+function renderEntryRow(entry: Entry, nodeId: string): string {
+	const ref: MessageRef = { sender: entry.message.sender, id: entry.message.id };
+	const related = entry.message.meta?.in_reply_to;
+	const lines = [
+		t("historyRow", {
+			prefix: t("historySeqPrefix", { seq: entry.seq }),
+			direction: entry.message.sender === nodeId ? "out" : "in",
+			sender: ref.sender,
+			at: entry.at,
+			status: t("ownerHeld"),
+		}),
+	];
+	if (related !== undefined) lines.push(t("replyTo", { ref: refKey(related), url: messagePath(related) }));
+	const work = workText(entry.message.meta?.work);
+	if (work !== undefined) lines.push(work);
+	lines.push(t("historyLinks", {
+		message: messagePath(ref),
+		conversation: conversationPath(ref),
+		entry: ownedEntryPath(entry.thread_ref, entry.seq),
+	}));
+	for (const line of entry.message.msg.split(/\r?\n/)) lines.push(`  > ${line}`);
+	return lines.join("\n");
+}
+
 function renderHistoryRow(row: HistoryMessage, nodeId: string): string {
 	const ref = row.message_ref;
 	const thread = row.thread_ref ?? row.message.meta?.thread;
@@ -1338,6 +1498,8 @@ function renderHistoryRow(row: HistoryMessage, nodeId: string): string {
 	if (related !== undefined) {
 		lines.push(t("replyTo", { ref: `${related.sender}/${related.id}`, url: messagePath(related) }));
 	}
+	const work = workText(row.message.meta?.work);
+	if (work !== undefined) lines.push(work);
 	const entry = thread === undefined || row.seq === undefined || thread.owner !== nodeId
 		? ""
 		: t("suffixEntry", { url: entryPath(thread, row.seq) });
@@ -1345,3 +1507,14 @@ function renderHistoryRow(row: HistoryMessage, nodeId: string): string {
 	for (const line of row.message.msg.split(/\r?\n/)) lines.push(`  > ${line}`);
 	return lines.join("\n");
 }
+
+/**
+ * The work unit a message belongs to (RFC 0003 §1), as the reader needs it: the unit a
+ * receiver dedupes on, the enclosing unit, and which attempt this is.
+ */
+function workText(work: WorkRef | undefined): string | undefined {
+	if (work === undefined) return undefined;
+	const parent = work.parent === undefined || work.parent === null ? "" : t("workParent", { unit: work.parent });
+	const attempt = work.attempt === undefined ? "" : t("workAttempt", { attempt: String(work.attempt) });
+	return t("workLine", { unit: work.unit, parent, attempt });
+}

package/src/work.ts

@@ -0,0 +1,10 @@
+import type { WorkRef } from "@onlyne/lib";
+
+/** The work unit as one readable value: the dedupe key, its parent and the attempt number. */
+export function workValue(work: WorkRef): string {
+	return [
+		work.unit,
+		work.parent === undefined || work.parent === null ? "" : `parent ${work.parent}`,
+		work.attempt === undefined ? "" : `attempt ${work.attempt}`,
+	].filter(part => part.length > 0).join(" · ");
+}

package/src/host-text.ts

@@ -1,86 +0,0 @@
-import { createTranslator } from "@onlyne/node-host/i18n";
-const en = {
-  regionEmpty: "region must not be empty.",
-  nodeIdEmpty: "node.id must not be empty.",
-  addressEmpty: "A node address must not be empty.",
-  addressUrl: "A node address must be an absolute URL, got {value}.",
-  addressScheme: "A node address must use http or https, got {value}.",
-  addressShape: "A node address is an origin (http://host:7801) or a service URL (http://host:7801{service}), got {value}.",
-  configMissing: "No Onlyne configuration at {path}. Run /onlyne init to create it.",
-  configParse: "{path}: {error}",
-  languageInvalid: "language must be en or zh-CN.",
-  keyScopeInvalid: "node.key_scope must be project, global or none, got {value}.",
-  publicUrlEmpty: "server.public_url must not be empty.",
-  bindEmpty: "server.bind must not be empty.",
-  bindShape: "server.bind must be a hostname or IP address, got {value}.",
-  pageSizeRange: "threads.page_size must be an integer from 1 to 100, got {value}.",
-  retiredEndpoint: "node.endpoint is not supported; the endpoint comes from server.bind and the assigned port.",
-  retiredPort: "server.port is not supported; the operating system assigns the listening port.",
-  retiredPeers: "peers is not supported; peers are discovered over the network and kept in the project SQLite.",
-  retiredOmp: "omp is not supported; delivery and spawning are decided by the OMP judge.",
-  retiredAttention: "threads.default_attention is not supported; reads default to the attention list.",
-  tableExpected: "{path}: {key} must be a table.",
-  stringExpected: "{field} must be a string.",
-  integerExpected: "{field} must be an integer.",
-  stringArrayExpected: "{field} must be an array of non-empty strings.",
-  trustArray: "{path}: trust must be an array of tables.",
-  trustEntry: "{path}: a trust entry needs node_id and a 16-character fingerprint.",
-  addressUnavailable: "No concrete network address is available for this bind host.",
-  keyProvider: "External credential references need a host key provider.",
-  loopbackBind: "The unauthenticated development binding requires a loopback bind host. Create a node key to serve a remote address.",
-  managementIdentity: "HTTP callers cannot claim this node's management identity.",
-  mentionNotFound: "No unique discovered node is named {name}.",
-  guideContacts: "Contacts",
-  guidePending: "Pending",
-  guideAccept: "Accept",
-  guideDiscover: "Discover",
-  guideRequestExchange: "Request key exchange",
-  resourcePageSize: "page_size must be from 1 to 100.",
-  resourceOwner: "Resource owner must be a non-empty node id.",
-  resourceRef: "Resource reads need meta.resource {owner,id}.",
-  resourceSince: "since must be a decimal event id.",
-  resourceOp: "Resource reads use list, describe, log, event with event_id, operations, or status with operation_id.",
-};
-const zh: Record<keyof typeof en, string> = {
-  regionEmpty: "region 不能为空。",
-  nodeIdEmpty: "node.id 不能为空。",
-  addressEmpty: "节点地址不能为空。",
-  addressUrl: "节点地址必须是绝对 URL，收到的是 {value}。",
-  addressScheme: "节点地址必须使用 http 或 https，收到的是 {value}。",
-  addressShape: "节点地址应写成源站（http://host:7801）或服务 URL（http://host:7801{service}），收到的是 {value}。",
-  configMissing: "在 {path} 没有 Onlyne 配置。运行 /onlyne init 创建。",
-  configParse: "{path}: {error}",
-  languageInvalid: "language 必须是 en 或 zh-CN。",
-  keyScopeInvalid: "node.key_scope 必须是 project、global 或 none，收到的是 {value}。",
-  publicUrlEmpty: "server.public_url 不能为空。",
-  bindEmpty: "server.bind 不能为空。",
-  bindShape: "server.bind 必须是主机名或 IP 地址，收到的是 {value}。",
-  pageSizeRange: "threads.page_size 必须是 1 到 100 之间的整数，收到的是 {value}。",
-  retiredEndpoint: "不支持 node.endpoint；端点由 server.bind 和系统分配的端口决定。",
-  retiredPort: "不支持 server.port；监听端口由操作系统分配。",
-  retiredPeers: "不支持 peers；对端通过网络发现，并保存在项目 SQLite 中。",
-  retiredOmp: "不支持 omp；投送与派生由 OMP judge 决定。",
-  retiredAttention: "不支持 threads.default_attention；读取默认使用关注列表。",
-  tableExpected: "{path}: {key} 必须是表。",
-  stringExpected: "{field} 必须是字符串。",
-  integerExpected: "{field} 必须是整数。",
-  stringArrayExpected: "{field} 必须是非空字符串数组。",
-  trustArray: "{path}: trust 必须是表数组。",
-  trustEntry: "{path}: 每条 trust 记录需要 node_id 和 16 个字符的指纹。",
-  addressUnavailable: "这个绑定主机没有可用的具体网络地址。",
-  keyProvider: "外部凭据引用需要主机密钥提供者。",
-  loopbackBind: "未认证的开发绑定需要回环绑定主机。要对外提供服务，请创建节点密钥。",
-  managementIdentity: "HTTP 调用方不能冒用本节点的管理身份。",
-  mentionNotFound: "没有唯一发现到的节点名为 {name}。",
-  guideContacts: "联系人",
-  guidePending: "待确认",
-  guideAccept: "同意",
-  guideDiscover: "发现",
-  guideRequestExchange: "请求交换密钥",
-  resourcePageSize: "page_size 必须是 1 到 100。",
-  resourceOwner: "资源 owner 必须是非空节点 id。",
-  resourceRef: "读取资源需要 meta.resource {owner,id}。",
-  resourceSince: "since 必须是十进制事件 id。",
-  resourceOp: "读取资源可用 list、describe、log、带 event_id 的 event、operations，或带 operation_id 的 status。",
-};
-export const hostText = createTranslator({ en, "zh-CN": zh });