omp-onlyne 0.1.0 → 0.2.0

package/src/tool.ts

@@ -1,10 +1,10 @@
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type ExtensionAPI, type ExtensionContext, type SessionEntry, z } from "@oh-my-pi/pi-coding-agent";
-import type { Json, MsgInput, SendOutcome } from "@onlyne/lib";
+import { OnlyneError, trustPhase, type Json, type MsgInput, type SendOutcome } from "@onlyne/lib";
 import { runDecision } from "./decider.ts";
 import { createDraft, sendDraft } from "./drafts.ts";
 import { observeToolResult } from "./messages.ts";
-import { getRuntime } from "./runtime.ts";
+import { getRuntime, type PluginRuntime } from "./runtime.ts";
 import { toolText } from "./tool-text.ts";
 
 /** Custom entry naming a reply an `await` returned, left pending for the host bridge to confirm. */
@@ -57,10 +57,33 @@ export function registerMsgTool(pi: ExtensionAPI): void {
 					const draft = result as { draft_id: string };
 					return { content: [{ type: "text", text: toolText("draft.ready", { draft_id: draft.draft_id }) }], details: { result } };
 				}
+				// RFC 0018 §3.1: a trust action is mechanical — no judging, and no action kind
+				// invented for it, because the library executes exactly five and a trust action is
+				// not one of them (client.ts admits send, read, thread, resource and domain).
+				if (op === "trust_accept" || op === "trust_revoke" || op === "trust_begin") {
+					if (ctx.agent.kind === "sub") throw new OnlyneError("forbidden", toolText("failure.trust_main_only"));
+					const node = await trustNode(runtime, op, parsed.data.meta);
+					if (op === "trust_revoke") {
+						await runtime.acquireRevoke(node);
+						return { content: [{ type: "text", text: toolText("trust.revoked", { node }) }], details: { result: { op, node_id: node } } };
+					}
+					if (op === "trust_begin") {
+						const entry = await runtime.acquireBegin(node);
+						return {
+							content: [{ type: "text", text: toolText("trust.begun", { node, fingerprint: entry.fingerprint, phase: trustPhase(entry) }) }],
+							details: { result: entry },
+						};
+					}
+					const entry = await runtime.acquireAccept(node, trustField(parsed.data.meta, "fingerprint"));
+					return {
+						content: [{ type: "text", text: toolText("trust.accepted", { node, fingerprint: entry.fingerprint, phase: trustPhase(entry) }) }],
+						details: { result: entry },
+					};
+				}
 				if (typeof parsed.data.meta?.draft_id === "string") {
 					const result = await sendDraft(runtime, ctx, parsed.data.meta.draft_id, signal);
 					recordAwaitResult(pi, toolCallId, result, ctx);
-					return { content: [{ type: "text", text: `${summary(result)}\n\n${JSON.stringify(visibleResult(result), null, 2)}` }], details: { result: visibleResult(result) } };
+					return { content: [{ type: "text", text: `${summary(result, spelling(parsed.data.meta?.to))}\n\n${JSON.stringify(visibleResult(result), null, 2)}` }], details: { result: visibleResult(result) } };
 				}
 				const targets = parsed.data.meta?.to;
 				if (Array.isArray(targets)) {
@@ -78,7 +101,7 @@ export function registerMsgTool(pi: ExtensionAPI): void {
 						}
 					}
 					const text = rows.map(row => row.error === undefined
-						? toolText("multi.delivered", { to: String(row.to), summary: summary(row.outcome) })
+						? toolText("multi.delivered", { to: String(row.to), summary: summary(row.outcome, spelling(row.to)) })
 						: toolText("multi.failed", { to: String(row.to), error: row.error })).join("\n");
 					pi.logger.info("onlyne.msg.multi", { targets: rows.length, failed: rows.filter(row => row.error !== undefined).length });
 					return { content: [{ type: "text", text: `${text}\n\n${JSON.stringify(rows, null, 2)}` }], details: { result: rows } };
@@ -92,8 +115,11 @@ export function registerMsgTool(pi: ExtensionAPI): void {
 				recordAwaitResult(pi, toolCallId, result, ctx);
 				const visible = visibleResult(result);
 				pi.logger.info("onlyne.msg.result", { kind: input.delivery_kind, ms: Date.now() - started, ...outcomeFacts(result) });
+				const text = op === "member_add" || op === "member_remove"
+					? membershipText(op, visible, parsed.data.meta)
+					: summary(result, spelling(parsed.data.meta?.to));
 				return {
-					content: [{ type: "text", text: `${summary(result)}\n\n${JSON.stringify(visible, null, 2)}` }],
+					content: [{ type: "text", text: `${text}\n\n${JSON.stringify(visible, null, 2)}` }],
 					details: { result: visible },
 				};
 			} catch (error) {
@@ -112,22 +138,47 @@ export function registerMsgTool(pi: ExtensionAPI): void {
  * `wait: timed_out` beside `admission: accepted` reads as a contradiction until the
  * reader knows the contract — so the delivery fact is stated first and the JSON below
  * it is for the rare case that needs a machine-readable detail.
+ *
+ * `addressed` is the target as the caller wrote it. A receipt names the thread's owner, which
+ * is this node whenever it started the conversation, so leading with it made a message to a
+ * peer read as a message to itself; the addressee comes first and the storage second.
  */
-export function summary(result: unknown): string {
+export function summary(result: unknown, addressed?: string): string {
 	if (result === null || typeof result !== "object") return toolText("summary.no_result");
 	const outcome = result as Partial<SendOutcome>;
-	const owner = outcome.receipt?.thread_ref?.owner ?? outcome.reply?.thread_ref.owner;
-	const where = owner === undefined ? "" : toolText("summary.where", { owner });
+	const receipt = outcome.receipt;
+	// The message's own sender is this node: `send` refuses a message another node authors.
+	const self = receipt?.message_ref.sender;
+	const to = outcome.resolved ?? outcome.requested ?? addressed;
 	// The answer is part of the delivery fact: a reply the receipt cannot attribute is one the
 	// sender cannot prove landed on the message it meant (cyanea report 2, problem 2).
-	const answers = outcome.receipt?.in_reply_to;
+	const answers = receipt?.in_reply_to;
 	const answering = answers === undefined ? "" : toolText("summary.answering", { sender: answers.sender, id: answers.id });
-	const facts = outcome.receipt === undefined
-		? ""
-		: toolText("summary.thread_ref", { thread: outcome.receipt.thread_ref.id, seq: outcome.receipt.seq, answering });
-	// The receipt names a thread the receiver owns, which is not a local object; the outbound
-	// record is. Point the reader at the handle that opens (dpdp report, problem 1).
-	const trail = outcome.receipt === undefined ? "" : toolText("summary.outbound", { id: outcome.receipt.message_ref.id });
+	// The receipt names the thread owner, which is this node when it started the conversation;
+	// a peer's thread is stored at the peer, so the two cases are stated apart.
+	const storedHere = receipt !== undefined && receipt.thread_ref.owner === self;
+	const storage = receipt === undefined ? "" : toolText(storedHere ? "summary.stored_here" : "summary.stored_there", {
+		owner: receipt.thread_ref.owner, thread: receipt.thread_ref.id, seq: receipt.seq, answering,
+	});
+	const facts = [
+		// The self case is the one the reader has to be told about: this node's own id reads as a
+		// peer name, and the thread is hosted here either way.
+		to === undefined ? "" : toolText(to === self ? "summary.addressee_self" : "summary.addressee", { to }),
+		storage,
+		// The resolved addressee is what keeps an alias send from reading as a self-send.
+		outcome.resolved === undefined || outcome.resolved === outcome.requested ? "" : toolText("summary.resolved", { node: outcome.resolved }),
+		// The receipt names a thread the receiver owns, which is not a local object; the outbound
+		// record is. Point the reader at the handle that opens (dpdp report, problem 1).
+		receipt === undefined ? "" : toolText("summary.outbound", { id: receipt.message_ref.id }),
+	].filter(part => part.length > 0).join(toolText("summary.sep"));
+	// A thread this node hosts and a peer it addressed: the entry sits here because this node
+	// hosts the thread, so the sentence names the addressee that reads it. Without that, "hosted
+	// on your node" beside "Sent to <peer>" reads as a message this node wrote to itself.
+	const mechanism = storedHere && to !== undefined && to !== self
+		? toolText("summary.grant_notice", { to })
+		: "";
+	// With no addressee the sentence opens on the storage fact, so it is capitalized like a lead.
+	const body = to === undefined && facts.length > 0 ? facts.charAt(0).toUpperCase() + facts.slice(1) : facts;
 	if (outcome.admission !== undefined) {
 		if (outcome.admission !== "accepted") {
 			const error = outcome.error;
@@ -139,23 +190,31 @@ export function summary(result: unknown): string {
 				: toolText("summary.recover");
 			return toolText("summary.not_confirmed", { failure, next });
 		}
+		// No receipt means no addressee and no storage to state; the JSON below carries the rest.
+		if (body.length === 0) return toolText("summary.plain");
+		const vars = { facts: body, mechanism };
 		if (outcome.wait === "answered" && outcome.reply !== undefined) {
-			const answer = { author: outcome.reply.authenticated_author, seq: outcome.reply.seq, where, facts, trail };
+			const answer = { ...vars, author: outcome.reply.authenticated_author, seq: outcome.reply.seq };
 			return outcome.reply_body === "withheld"
 				? toolText("summary.delivered_withheld", answer)
 				: toolText("summary.delivered_answered", answer);
 		}
 		if (outcome.wait === "timed_out") {
-			return toolText("summary.delivered_timed_out", { where, facts, trail });
+			return toolText("summary.delivered_timed_out", vars);
 		}
 		if (outcome.wait === "cancelled") {
-			return toolText("summary.delivered_cancelled", { where, facts, trail });
+			return toolText("summary.delivered_cancelled", vars);
 		}
-		return toolText("summary.delivered", { where, facts, trail });
+		return toolText("summary.delivered", vars);
 	}
 	return toolText("summary.plain");
 }
 
+/** The caller's spelling of one target, when it is a plain name rather than a structured ref. */
+function spelling(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
 /** The facts one `msg` call produced, without the reply body. */
 function outcomeFacts(result: unknown): Record<string, unknown> {
 	if (result === null || typeof result !== "object") return {};
@@ -234,3 +293,50 @@ function failure(text: string): AgentToolResult<{ result: unknown }> {
 		isError: true,
 	};
 }
+
+/**
+ * RFC 0018 §3.1: a trust op names its peer mechanically. The fields are read before any
+ * judgement or storage write, so a malformed call is a caller error, never a policy answer.
+ */
+function trustField(meta: Record<string, unknown> | undefined, field: string): string {
+	const value = meta?.[field];
+	if (typeof value !== "string" || value.length === 0) throw new OnlyneError("invalid_request", toolText("failure.trust_fields", { field }));
+	return value;
+}
+
+/**
+ * RFC 0018 §3.1: the peer a trust op names, resolved through the same peer set a send resolves
+ * `meta.to` from. An ambiguous alias names its matches; an unknown one is `not_found` and says
+ * which action asked, because the same alias may be valid for another one.
+ */
+async function trustNode(runtime: PluginRuntime, op: string, meta: Record<string, unknown> | undefined): Promise<string> {
+	const node = trustField(meta, "node_id");
+	try {
+		return await runtime.decider.peerId(node);
+	} catch (error) {
+		if (error instanceof OnlyneError && error.error.code === "not_found") {
+			throw new OnlyneError("not_found", toolText("failure.trust_node_unknown", { action: op, node }), error.error.details);
+		}
+		throw error;
+	}
+}
+
+/** The sentence one membership op earns: the member, the thread, and where a later array send lands. */
+function membershipText(op: "member_add" | "member_remove", result: unknown, meta: Record<string, unknown> | undefined): string {
+	const named = result !== null && typeof result === "object" && "peer" in result && typeof result.peer === "string"
+		? result.peer
+		: threadLabel(meta?.to);
+	return toolText(op === "member_add" ? "thread.member_added" : "thread.member_removed", {
+		member: named,
+		thread: threadLabel(meta?.thread),
+	});
+}
+
+/** A reference as the caller wrote it: one name, or `owner/id` for the record form. */
+function threadLabel(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return "";
+	const owner = "owner" in value ? value.owner : undefined;
+	const id = "id" in value ? value.id : undefined;
+	return typeof owner === "string" && typeof id === "string" ? `${owner}/${id}` : "";
+}

package/src/types.ts

@@ -1,5 +1,6 @@
 import type { MessageRef, NodeId, ThreadRef, TrustPhase, TrustSeed } from "@onlyne/lib";
 import type { Locale } from "@onlyne/node-host/i18n";
+import type { AcquisitionPolicy } from "./acquire.ts";
 
 /**
  * Project-scoped configuration in `<project>/.onlyne/config.toml`.
@@ -20,6 +21,12 @@ export interface OnlyneConfig {
 	};
 	server: {
 		bind: string;
+		/**
+		 * The port this node answers on. Absent asks the operating system for one, and the
+		 * chosen port is written back here: a node whose address changes on every start
+		 * leaves every peer that recorded it calling a port nobody serves.
+		 */
+		port?: number;
 		/** The externally reachable base URL when a reverse proxy fronts the node. */
 		public_url?: string;
 	};
@@ -32,6 +39,8 @@ export interface OnlyneConfig {
 	};
 	/** Pinned peer fingerprints; an arriving key that matches is trusted without a prompt. */
 	trust?: TrustSeed[];
+	/** RFC 0018 §2: peers this node may approve without a human confirming first. */
+	acquisition?: AcquisitionPolicy;
 }
 
 /** One execution context the plugin registered for a delivered message. */
@@ -79,6 +88,11 @@ export interface ViewerThread {
 	unread: number;
 	last_seq: string;
 	messages: ViewerMessage[];
+	/**
+	 * A thread another node hosts: this node was invited into it, so the viewer can show it and
+	 * cannot offer the writes that belong to its owner.
+	 */
+	read_only?: boolean;
 }
 
 /** One discovery record row the viewer lists as an automatic-discovery candidate. */

package/src/ui/bootstrap.ts

@@ -172,10 +172,15 @@ export class OnlyneBootstrap implements Component {
 				// The form does not edit these; saving must not erase them.
 				...(previous?.node.key_ref === undefined ? {} : { key_ref: previous.node.key_ref }),
 			},
-			server: { bind, ...(previous?.server.public_url === undefined ? {} : { public_url: previous.server.public_url }) },
+			server: {
+				bind,
+				...(previous?.server.port === undefined ? {} : { port: previous.server.port }),
+				...(previous?.server.public_url === undefined ? {} : { public_url: previous.server.public_url }),
+			},
 			threads: { page_size: Number(this.value("pageSize")) },
 			...(seeds.length === 0 ? {} : { discovery: { seeds } }),
 			...(previous?.trust === undefined ? {} : { trust: previous.trust }),
+			...(previous?.acquisition === undefined ? {} : { acquisition: previous.acquisition }),
 			...(previous?.language === undefined ? {} : { language: previous.language }),
 		};
 		this.saving = true;

package/src/ui/viewer-text.ts

@@ -24,6 +24,7 @@ const en = {
 
 	"send.blocked.empty": "Type a message first.",
 	"send.blocked.noTarget": "Open a thread first, or pick a recipient.",
+	"send.blocked.readOnly": "This thread is read-only here: its owner holds it, so send from a node that owns it.",
 
 	"rail.domain.title": "{label} · nodes {count}",
 	"rail.empty": "no domains",
@@ -36,6 +37,7 @@ const en = {
 	"sidebar.inbox": "✉ Inbox",
 	"sidebar.noKey": "no node key",
 	"thread.closed": "closed",
+	"thread.readOnly": "read-only",
 
 	"key.missing": "this node has no key",
 	"approvals.head": "{node} asks to exchange keys with you",
@@ -173,6 +175,7 @@ const zh: Record<ViewerTextKey, string> = {
 
 	"send.blocked.empty": "输入内容后发送",
 	"send.blocked.noTarget": "先打开线程，或选择收件人",
+	"send.blocked.readOnly": "这个线程在此只读：它由所有者托管，请从拥有它的节点发送。",
 
 	"rail.domain.title": "{label} · {count} 节点",
 	"rail.empty": "无域",
@@ -185,6 +188,7 @@ const zh: Record<ViewerTextKey, string> = {
 	"sidebar.inbox": "✉ 收件箱",
 	"sidebar.noKey": "无节点密钥",
 	"thread.closed": "已关闭",
+	"thread.readOnly": "只读",
 
 	"key.missing": "本节点没有密钥",
 	"approvals.head": "{node} 请求与你交换密钥",

package/src/ui/viewer.ts

@@ -17,6 +17,7 @@ import {
 } from "@oh-my-pi/pi-tui";
 import { normalizeServiceUrl, shortNodeId } from "../config.ts";
 import { getRuntime } from "../runtime.ts";
+import { runDecision } from "../decider.ts";
 import type { OnlyneStatus, ViewerDiscovery, ViewerMessage, ViewerSnapshot, ViewerThread } from "../types.ts";
 import { ageText, clockText, fit, oneLine, shortAlias, sinceText } from "./format.ts";
 import { type ViewerTextKey, t } from "./viewer-text.ts";
@@ -337,7 +338,11 @@ export class OnlyneViewer implements Component {
 	private sendBlocked(): string | undefined {
 		if (this.error !== undefined) return this.error;
 		if (this.draft.trim() === "") return t("send.blocked.empty");
-		if (this.target === undefined && this.replyTo === undefined && this.selectedThread() === undefined) {
+		const thread = this.selectedThread();
+		// A joined thread is another node's: the viewer shows it and offers no write it cannot
+		// perform. A manual recipient starts a new message and is unaffected.
+		if (this.target === undefined && thread?.read_only === true) return t("send.blocked.readOnly");
+		if (this.target === undefined && this.replyTo === undefined && thread === undefined) {
 			return t("send.blocked.noTarget");
 		}
 		return undefined;
@@ -479,7 +484,11 @@ export class OnlyneViewer implements Component {
 				node(
 					"item",
 					{
-						label: [span(`# ${thread.title}`, open ? "strong" : undefined), ...(thread.state === "closed" ? [span(` ${t("thread.closed")}`, "dim")] : [])],
+						label: [
+							span(`# ${thread.title}`, open ? "strong" : undefined),
+							...(thread.state === "closed" ? [span(` ${t("thread.closed")}`, "dim")] : []),
+							...(thread.read_only === true ? [span(` ${t("thread.readOnly")}`, "dim")] : []),
+						],
 						// One number per row, always the same number: the unread count. A row that
 						// showed the message total once everything was read made two rows of equal
 						// width mean different things.
@@ -753,7 +762,11 @@ export class OnlyneViewer implements Component {
 				children.push(
 					node("row", { role: "onlyne.thread-head", gap: "md", align: "center", justify: "between" }, [
 						node("col", { gap: "none", grow: 1 }, [
-							textNode([span(`# ${thread.title}`, "strong"), ...(thread.state === "closed" ? [span(` · ${t("thread.closed")}`, "dim")] : [])], { truncate: "end" }),
+							textNode([
+								span(`# ${thread.title}`, "strong"),
+								...(thread.state === "closed" ? [span(` · ${t("thread.closed")}`, "dim")] : []),
+								...(thread.read_only === true ? [span(` · ${t("thread.readOnly")}`, "dim")] : []),
+							], { truncate: "end" }),
 							textNode([span(t("thread.meta", {
 								messages: messages.length,
 								speakers: new Set(messages.map(message => message.author)).size,
@@ -1282,7 +1295,11 @@ export class OnlyneViewer implements Component {
 		this.sending = true;
 		this.changed();
 		try {
-			const outcome = (await runtime.node.client.msg(input, { context: runtime.mainAgentId })) as SendOutcome;
+			// The library decides every send through the plugin, and the plugin only decides inside
+			// a bound scope: without one the composer reported a send failure (audit §2.3). The
+			// panel is the main session's input, so it carries the main session's scope.
+			const outcome = (await runDecision({ ctx: runtime.main, input }, () =>
+				runtime.node.client.msg(input, { context: runtime.mainAgentId }))) as SendOutcome;
 			this.setNotice(this.describeOutcome(outcome), outcome.admission === "refused" || outcome.error !== undefined);
 			if (outcome.admission === "accepted" || outcome.admission === "unknown") {
 				this.draft = "";

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",
@@ -167,6 +176,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 +185,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 +197,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: "无访问权限",