pi-roundtable 0.8.0 → 0.9.0

package/src/core/discord/owner-cards.ts

@@ -14,20 +14,21 @@ import {
 } from "discord.js";
 import { parseChannelKey } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
+import { messages } from "../i18n/index.ts";
 import type {
 	Approval,
 	OwnerAnswer,
-	OwnerPrompts,
 	OwnerQuestion,
-} from "../domain/owner-prompts.ts";
-import { messages } from "../i18n/index.ts";
+	PromptScope,
+	Prompts,
+} from "../interactions/prompts.ts";
 import type { Logger } from "../log.ts";
 import {
-	type Speaker,
-	type SpeakerPolicy,
-	type Tier,
-	tierAtLeast,
-} from "../speakers.ts";
+	type Audience,
+	type CardAudienceOptions,
+	CardAudiences,
+} from "./card-audience.ts";
+import { DiscordOwners, discordUser } from "./discord-owners.ts";
 import type { InteractionModule } from "./interaction-module.ts";
 import { ownerPanel, type PanelContent, plain } from "./owner-panel.ts";
 
@@ -37,7 +38,7 @@ export const CARD_TIMEOUT_MS = 30 * 60_000;
 const OTHER = "other";
 const TEXT_FIELD = "text";
 
-/** A card's message: the panel, led by a mention of the owner in a thread. */
+/** A card's message: the panel, led in a thread by a mention of those it is for. */
 export type CardPayload = Omit<
 	ReturnType<typeof ownerPanel>,
 	"components" | "allowedMentions"
@@ -57,14 +58,18 @@ export interface CardMessage {
 /** Where a channel's cards are posted. */
 export interface CardChannel {
 	send(payload: CardPayload): Promise<CardMessage>;
-	/** A thread, where the owner is mentioned so they hear of the card; a channel never mentions them. */
+	/** A thread, where those a card is for are mentioned so they hear of it; a channel mentions no one. */
 	thread?: boolean;
 }
 
 export interface OwnerCardsOptions {
+	/** The primary owner's Discord user id. */
 	ownerId: string;
-	/** Decides who holds a tier, for cards that lower tiers may answer; without it only the owner answers. */
-	speakers?: SpeakerPolicy;
+	/**
+	 * Who holds a tier now, and which owners have a Discord identity, for cards that others than
+	 * the primary owner may answer; without it only the primary owner answers.
+	 */
+	identity?: CardAudienceOptions["identity"];
 	/** The Discord channel by id; throws when it cannot take messages. */
 	channel(channelId: string): Promise<CardChannel>;
 	logger: Logger;
@@ -91,42 +96,41 @@ interface OpenCard {
 	audience: Audience;
 }
 
-/** The people a card is for. */
-interface Audience {
-	allows(user: { id: string; roleIds: readonly string[] }): boolean;
-	/** The user the card mentions in a thread. */
-	mentionId: string;
-	/** Shown on the card. */
-	note: string;
-	refusal: string;
-}
-
 /**
- * The owner's cards in the assistant's channels: approvals of held actions and ask_user questions,
- * answered with buttons, a menu, or a form. The owner may answer, and so may the speaker whose
- * turn asks, when the card allows (a question always; an approval at its tier); an unanswered card
- * expires after 30 minutes and a stopped turn cancels it. Open cards live in memory, so a
- * restart abandons them; pressing one then says it no longer works.
+ * The cards in the assistant's channels: approvals of held actions and ask_user questions,
+ * answered with buttons, a menu, or a form, by those the turn's prompt scope names (see
+ * `CardAudiences`): the speaker whose turn asks, when the card allows (a question always; an
+ * approval at its tier), and, in a shared conversation, the owners. An unanswered card expires
+ * after 30 minutes and a stopped turn cancels it. Open cards live in memory, so a restart
+ * abandons them; pressing one then says it no longer works.
  */
 export class OwnerCards implements InteractionModule {
 	readonly #options: OwnerCardsOptions;
+	readonly #audiences: CardAudiences;
 	readonly #open = new Map<string, OpenCard>();
 
 	constructor(options: OwnerCardsOptions) {
 		this.#options = options;
+		this.#audiences = new CardAudiences(options, new DiscordOwners(options));
 	}
 
 	commands() {
 		return [];
 	}
 
-	/** The channel's cards; the chat surface port sends only Discord keys here. */
-	prompts(channel: ChannelKey, speaker?: Speaker): OwnerPrompts | undefined {
+	/**
+	 * The channel's cards for the scope's turn; without a scope they are the owners'. The chat
+	 * surface port sends only Discord keys here.
+	 */
+	prompts(channel: ChannelKey, scope?: PromptScope): Prompts | undefined {
 		const channelId = parseChannelKey(channel).id;
 		return {
-			confirm: (title, message, signal, minTier = "owner") =>
-				this.#post<Approval>(channelId, signal, "expired", "cancelled", {
-					audience: this.#approvers(minTier, speaker),
+			confirm: async (title, message, signal, minTier = "owner") => {
+				const audience = await this.#audiences.approval(scope, minTier);
+				// A private conversation's call above its person's tier is no one's to approve.
+				if (!audience) return "expired";
+				return this.#post<Approval>(channelId, signal, "expired", "cancelled", {
+					audience,
 					title,
 					sections: [message],
 					rows: (id, disabled) => [
@@ -146,22 +150,26 @@ export class OwnerCards implements InteractionModule {
 						),
 					],
 					footer: messages().cardApprovalFooter,
-				}),
-			ask: (title, question, signal) =>
-				this.#post<OwnerAnswer | undefined>(
+				});
+			},
+			ask: async (title, question, signal) => {
+				const audience = await this.#audiences.question(scope);
+				if (!audience) return undefined;
+				return this.#post<OwnerAnswer | undefined>(
 					channelId,
 					signal,
 					undefined,
 					undefined,
 					{
-						audience: this.#asker(speaker),
+						audience,
 						title,
 						sections: [question.question],
 						question,
 						rows: (id, disabled) => askRows(id, question, disabled),
 						footer: messages().cardQuestionFooter,
 					},
-				),
+				);
+			},
 		};
 	}
 
@@ -214,7 +222,7 @@ export class OwnerCards implements InteractionModule {
 						footer,
 					},
 					open.mention === true,
-					card.audience.mentionId,
+					card.audience.mentions,
 				);
 			const abort = () => settle(cancelled, messages().cardStopped);
 			const timer = setTimeout(
@@ -250,67 +258,22 @@ export class OwnerCards implements InteractionModule {
 	}
 
 	/** The card's panel; in a thread it leads with the mention of who may answer. */
-	#panel(content: PanelContent, mention: boolean, userId: string): CardPayload {
+	#panel(
+		content: PanelContent,
+		mention: boolean,
+		userIds: readonly string[],
+	): CardPayload {
 		const panel = ownerPanel(content);
 		if (!mention) return panel;
 		return {
 			...panel,
 			components: [
-				new TextDisplayBuilder().setContent(`<@${userId}>`),
+				new TextDisplayBuilder().setContent(
+					userIds.map((id) => `<@${id}>`).join(" "),
+				),
 				...panel.components,
 			],
-			allowedMentions: { users: [userId] },
-		};
-	}
-
-	/**
-	 * An approval is for the speaker whose turn held the call, when their tier holds it, and for
-	 * the owner; the owner's alone by default. Nobody else in the channel may approve it.
-	 */
-	#approvers(minTier: Tier, speaker: Speaker | undefined): Audience {
-		const { ownerId, speakers } = this.#options;
-		if (
-			minTier === "owner" ||
-			!speakers ||
-			!speaker ||
-			speaker.id === ownerId ||
-			!tierAtLeast(speaker.tier, minTier)
-		)
-			return {
-				allows: (user) => user.id === ownerId,
-				mentionId: ownerId,
-				note: "",
-				refusal: messages().cardOwnerOnly,
-			};
-		return {
-			allows: (user) => {
-				if (user.id === ownerId) return true;
-				if (user.id !== speaker.id) return false;
-				// Their tier when they press, in case it was lowered during the turn.
-				const who = speakers.resolve({ ...user, name: "" });
-				return who !== undefined && tierAtLeast(who.tier, minTier);
-			},
-			mentionId: speaker.id,
-			note: messages().cardApproversNote(speaker.id),
-			refusal: messages().cardApproversRefusal,
-		};
-	}
-
-	/** A question is for the speaker whose turn asks it, and for the owner. */
-	#asker(speaker: Speaker | undefined): Audience {
-		const { ownerId } = this.#options;
-		if (!speaker || speaker.id === ownerId)
-			return {
-				allows: (user) => user.id === ownerId,
-				mentionId: ownerId,
-				note: "",
-				refusal: messages().cardOwnerOnly,
-			};
-		return {
-			allows: (user) => user.id === speaker.id || user.id === ownerId,
-			mentionId: speaker.id,
-			note: messages().cardAskerNote(speaker.id),
-			refusal: messages().cardAskerRefusal,
+			allowedMentions: { users: [...userIds] },
 		};
 	}
 
@@ -335,10 +298,8 @@ export class OwnerCards implements InteractionModule {
 			});
 			return true;
 		}
-		const { member } = interaction;
-		const roleIds =
-			member && "cache" in member.roles ? [...member.roles.cache.keys()] : [];
-		if (!card.audience.allows({ id: interaction.user.id, roleIds })) {
+		const user = discordUser(interaction);
+		if (!(await card.audience.allows(user))) {
 			await interaction.reply({
 				content: card.audience.refusal,
 				flags: MessageFlags.Ephemeral,
@@ -354,7 +315,7 @@ export class OwnerCards implements InteractionModule {
 					footer: outcome,
 				},
 				card.mention === true,
-				card.audience.mentionId,
+				card.audience.mentions,
 			);
 		if (interaction.isButton() && (action === "yes" || action === "no")) {
 			const approved = action === "yes";

package/src/core/discord/owner-command.ts

@@ -7,7 +7,13 @@ import {
 	SlashCommandSubcommandGroupBuilder,
 } from "discord.js";
 import { messages } from "../i18n/index.ts";
+import type { IdentityService } from "../identity/identity-service.ts";
 import type { Logger } from "../log.ts";
+import {
+	type DiscordActor,
+	DiscordOwners,
+	discordUser,
+} from "./discord-owners.ts";
 import type {
 	CommandGuard,
 	CommandRoot,
@@ -33,31 +39,36 @@ export const groupOption = (
 ): RootOption => build(new SlashCommandSubcommandGroupBuilder()).toJSON();
 
 /**
- * Only the owner may use the root command, checked by user ID; every answer is visible only to them,
- * and a failure becomes a panel instead of a hanging interaction.
+ * Only an owner may use the root command: the primary owner by user ID, and, with the identity
+ * service, every other owner principal's Discord identity, checked again each time. Every answer
+ * is visible only to them, and a failure becomes a panel instead of a hanging interaction.
  */
-// pi-lens-ignore: large-class — two methods: the owner check and the failure panel
+// pi-lens-ignore: large-class — three methods: the owner checks and the failure panel
 export class OwnerGuard implements CommandGuard {
-	readonly #ownerId: string;
+	readonly #owners: DiscordOwners;
 	readonly #logger: Logger;
 	/** The name of the root command the guard serves, without the slash. */
 	readonly root: string;
 	readonly refusalHint: string | undefined;
 
 	constructor(
-		ownerId: string,
+		owners: DiscordOwners,
 		logger: Logger,
 		root: string,
 		refusalHint?: string,
 	) {
-		this.#ownerId = ownerId;
+		this.#owners = owners;
 		this.#logger = logger;
 		this.root = root;
 		this.refusalHint = refusalHint;
 	}
 
+	allows(actor: DiscordActor): Promise<boolean> {
+		return this.#owners.isOwner(discordUser(actor));
+	}
+
 	isOwner(actor: { user: { id: string } }): boolean {
-		return actor.user.id === this.#ownerId;
+		return actor.user.id === this.#owners.primary;
 	}
 
 	/** Runs a handler; failures become a panel instead of a hanging interaction. */
@@ -82,8 +93,10 @@ export class OwnerGuard implements CommandGuard {
 
 /** What `commandGuard` needs. */
 export interface CommandGuardOptions {
-	/** The one user who may use the owner's commands. */
+	/** The primary owner's Discord user id, who may always use the owner's commands. */
 	ownerId: string;
+	/** Which other owners there are and whether they still are; without it only `ownerId` may. */
+	identity?: Pick<IdentityService, "resolve" | "owners" | "identities">;
 	/** The name of the root command the guard serves, without the slash. */
 	root: string;
 	/** Where a failing command is logged. */
@@ -94,9 +107,10 @@ export interface CommandGuardOptions {
 
 /** A guard for the owner's commands, such as the one a test hands a module; the Discord plugin makes its own. */
 export function commandGuard(options: CommandGuardOptions): CommandGuard {
+	const { ownerId, identity, logger } = options;
 	return new OwnerGuard(
-		options.ownerId,
-		options.logger,
+		new DiscordOwners({ ownerId, ...(identity ? { identity } : {}), logger }),
+		logger,
 		options.root,
 		options.refusalHint,
 	);
@@ -121,7 +135,7 @@ const refusal = (hint: string | undefined) =>
 		sections: [`${messages().ownerRefusalBody}${hint ?? ""}`],
 	});
 
-/** Answers a feature's root subcommands and components, for the owner only. */
+/** Answers a feature's root subcommands and components, for the owners only. */
 export function ownerCommandModule(
 	guard: CommandGuard,
 	handlers: OwnerCommandHandlers,
@@ -139,14 +153,14 @@ export function ownerCommandModule(
 		async handle(interaction) {
 			if (interaction.isAutocomplete()) {
 				if (!owned(interaction)) return false;
-				if (!guard.isOwner(interaction)) await interaction.respond([]);
+				if (!(await guard.allows(interaction))) await interaction.respond([]);
 				else await handlers.autocomplete?.(interaction);
 				return true;
 			}
 			if (await handlers.component?.(interaction)) return true;
 			if (!interaction.isChatInputCommand() || !owned(interaction))
 				return false;
-			if (!guard.isOwner(interaction)) {
+			if (!(await guard.allows(interaction))) {
 				await interaction.reply(refusal(guard.refusalHint));
 				return true;
 			}

package/src/core/discord/stop-button.ts

@@ -12,7 +12,7 @@ import type { CommandGuard, InteractionModule } from "./interaction-module.ts";
 
 export const STOP_BUTTON_ID = "roundtable:stop";
 
-/** The message a long turn shows: a stop button only the owner may press. */
+/** The message a long turn shows: a stop button only an owner may press. */
 export function stopPanel() {
 	return {
 		content: messages().stopNote,
@@ -29,13 +29,13 @@ export function stopPanel() {
 }
 
 export interface StopButtonOptions {
-	guard: Pick<CommandGuard, "isOwner">;
+	guard: Pick<CommandGuard, "allows">;
 	/** Stops the running turn of the channel the button was pressed in, through its claim. */
 	conversations: Pick<ConversationPort, "stop">;
 }
 
 /**
- * Answers a press of the stop button: only the owner stops the channel's turn, and the answer,
+ * Answers a press of the stop button: only an owner stops the channel's turn, and the answer,
  * visible only to whoever pressed, says whether one was running.
  */
 export function stopButtonModule(
@@ -46,7 +46,7 @@ export function stopButtonModule(
 		handle: async (interaction: Interaction) => {
 			if (!interaction.isButton() || interaction.customId !== STOP_BUTTON_ID)
 				return false;
-			const owner = options.guard.isOwner(interaction);
+			const owner = await options.guard.allows(interaction);
 			const stopped =
 				owner &&
 				options.conversations.stop(

package/src/core/domain/conversation.ts

@@ -27,10 +27,15 @@ export interface PendingConfirmation {
 	heldAt: Date;
 	calls: HeldCall[];
 	/**
-	 * The speaker whose turn held the calls. Besides the owner, only they may approve them, at a
-	 * tier that holds them; without one, the owner alone may.
+	 * The speaker whose turn held the calls, by their id on the surface. Besides the owners, only
+	 * they may approve them, at a tier that holds them; without one, the owners alone may.
 	 */
 	speakerId?: string;
+	/**
+	 * The principal of that speaker, who approves them on any of their identities; absent for
+	 * calls held before 0.9, which are matched by `speakerId`.
+	 */
+	principalId?: string;
 }
 
 /** A file produced for a reply; data is raw bytes, not a path or base64. */

package/src/core/domain/errors.ts

@@ -29,3 +29,8 @@ export class DelegationError extends Error {
 export class AgentError extends Error {
 	override name = "AgentError";
 }
+
+/** A principal, identity link, or role change that cannot be made; its message names what to fix. */
+export class IdentityError extends Error {
+	override name = "IdentityError";
+}

package/src/core/domain/ports.ts

@@ -7,6 +7,11 @@ import type { TurnProgress } from "./progress.ts";
 
 export type { AgentTurnScope };
 
+/** Who a turn's conversation belongs to. */
+export type TurnConversation =
+	| { visibility: "private"; principalId: string }
+	| { visibility: "shared" };
+
 export interface TurnRequest {
 	/** Where the turn's message arrived and its attachments are saved. */
 	channel: ChannelKey;
@@ -19,8 +24,18 @@ export interface TurnRequest {
 	confirmed?: boolean;
 	/** Set for a turn of an agent-server agent. */
 	agent?: AgentTurnScope;
-	/** The person the turn is for: who wrote the message, or who set up the work. */
-	speaker?: Speaker;
+	/**
+	 * The person the turn is for: who wrote the message, or who set up the work; the turn runs at
+	 * their tier. Required: a turn without one is refused, never run as the owner's. A plugin that
+	 * starts a turn on someone's behalf gets theirs from `IDENTITY.speakerFor`.
+	 */
+	speaker: Speaker;
+	/**
+	 * Who the conversation belongs to, as the host records it: `private` to one principal, or
+	 * `shared` by whoever its claim admits, which it is taken to be when absent. A private
+	 * conversation's prompts are its person's alone; a shared one's escalate to the owners.
+	 */
+	conversation?: TurnConversation;
 	/**
 	 * The conversation's kind, fixed when its session is made: the string a claim's `startFresh`
 	 * returns, which picks the persona of a non-agent conversation. "owner" when absent.
@@ -54,6 +69,16 @@ export type {
 	YesNoQuestion,
 } from "../contract/providers.ts";
 
+/** Sends a person a notice through their own channel; resolves false when they have none. */
+export interface Notifier {
+	notify(principalId: string, text: string): Promise<boolean>;
+}
+
+/**
+ * Sends the primary owner a direct message.
+ * @deprecated Since 0.9 there may be more than one owner: reach a person with a `Notifier`, such as
+ * `context.directChannels`. Goes away in 1.0.
+ */
 export interface OwnerNotifier {
 	notifyOwner(text: string): Promise<void>;
 }

package/src/core/host.ts

@@ -7,6 +7,7 @@ import { MigrationError, NotLinkedError, PluginError } from "./errors.ts";
 import { EventBus } from "./events.ts";
 import { HttpListeners, type ListenerConfig } from "./http/listeners.ts";
 import { type Locale, setLocale } from "./i18n/index.ts";
+import { contactsOf } from "./identity/identity-view.ts";
 import type { JudgeModel } from "./judging/model-judge.ts";
 import type { Logger } from "./log.ts";
 import type {
@@ -32,7 +33,7 @@ import {
 	conversationTurns,
 } from "./routing/conversation-turns.ts";
 import { surfacePort } from "./routing/surface-port.ts";
-import { CONVERSATIONS, RUNTIME } from "./services.ts";
+import { CONVERSATIONS, IDENTITY, RUNTIME } from "./services.ts";
 import { setTimeZone } from "./time.ts";
 import { type ToolTierTable, toolTiers } from "./tool-tiers.ts";
 
@@ -154,6 +155,7 @@ export class Roundtable {
 	#listeners: HttpListeners | undefined;
 	#pool: SQL | undefined;
 	readonly #queue = new ChannelQueue();
+	readonly #warned = new Set<string>();
 	readonly #tiers: ToolTierTable;
 	readonly #events: EventBus;
 	#services: ServiceRegistry | undefined;
@@ -191,6 +193,7 @@ export class Roundtable {
 		return {
 			handle: (message) => router().handle(message),
 			background: (turn) => router().background(turn),
+			runsAs: (turn) => router().runsAs(turn),
 			target: (name) => router().target(name),
 			startFresh: (channel) => router().startFresh(channel),
 			deleteConversation: (channel) => router().deleteConversation(channel),
@@ -198,18 +201,29 @@ export class Roundtable {
 			postsInPlace: (channel) => router().postsInPlace(channel),
 			owns: (channel) => router().owns(channel),
 			takesBackground: (channel) => router().takesBackground(channel),
+			takesSystemReports: (channel) => router().takesSystemReports(channel),
 		};
 	}
 
 	/** The contributed surfaces by channel prefix; every call before linking throws NotLinkedError. */
 	#surfaces(): SurfacePort {
-		return surfacePort(() => {
-			if (!this.#sessions)
-				throw new NotLinkedError(
-					"chat surfaces are linked once every plugin is set up. Use surfaces from a service's start or from a handler, not during setup.",
-				);
-			return this.#registry.surfaces;
-		});
+		return surfacePort(
+			() => {
+				if (!this.#sessions)
+					throw new NotLinkedError(
+						"chat surfaces are linked once every plugin is set up. Use surfaces from a service's start or from a handler, not during setup.",
+					);
+				return this.#registry.surfaces;
+			},
+			{ deprecated: (message) => this.#deprecated(message) },
+		);
+	}
+
+	/** Logs a deprecation once per host. */
+	#deprecated(message: string): void {
+		if (this.#warned.has(message)) return;
+		this.#warned.add(message);
+		this.#options.logger.warn(message);
 	}
 
 	/** Turns over the runtime plugin's runtime and the surfaces; every call before linking is refused with NotLinkedError. */
@@ -328,11 +342,16 @@ export class Roundtable {
 		const { routes, channels } = this.#registry;
 		this.#sessions = linkSessions(this.#registry);
 		this.#events.link(this.#registry.handlers);
+		const identity = this.#services.find(IDENTITY);
 		this.#router = new ChannelRouter({
 			claims: channels,
+			...(identity
+				? { contacts: contactsOf(identity), principals: identity }
+				: {}),
 			targets: (name) =>
 				this.#registry.backgroundTargets.find((t) => t.name === name),
 			queue: this.#queue,
+			surfaces: this.#surfaces(),
 			logger,
 			...(this.#options.conversations?.forwardJoinMs === undefined
 				? {}

package/src/core/i18n/cards.ts

@@ -11,10 +11,12 @@ export function cardsEn(ctx: CatalogContext) {
 		cardStopped: "⏹️ This round was stopped.",
 		cardExpired: "⌛ Timed out with no answer.",
 		cardOwnerOnly: `Only ${ctx.assistant}'s owner can answer this card.`,
-		cardApproversNote: (userId: string) => `-# Who can approve: <@${userId}>`,
+		cardApproversNote: (...userIds: readonly string[]) =>
+			`-# Who can approve: ${userIds.map((id) => `<@${id}>`).join(" ")}`,
 		cardApproversRefusal:
 			"This approval is for the speaker whose turn asked for it.",
-		cardAskerNote: (userId: string) => `-# Who can answer: <@${userId}>`,
+		cardAskerNote: (...userIds: readonly string[]) =>
+			`-# Who can answer: ${userIds.map((id) => `<@${id}>`).join(" ")}`,
 		cardAskerRefusal: "This question is for another speaker.",
 		cardInactive: `This card is no longer active (it timed out, or ${ctx.assistant} restarted); reply in text if you need to.`,
 		cardApproved: "✅ Approved to run.",
@@ -41,9 +43,11 @@ export function cardsZhTW(ctx: CatalogContext): ReturnType<typeof cardsEn> {
 		cardStopped: "⏹️ 這一輪已停止。",
 		cardExpired: "⌛ 已逾時，沒有回答。",
 		cardOwnerOnly: `只有 ${ctx.assistant} 的擁有者能回答這張卡片。`,
-		cardApproversNote: (userId: string) => `-# 可以核准的人：<@${userId}>`,
+		cardApproversNote: (...userIds: readonly string[]) =>
+			`-# 可以核准的人：${userIds.map((id) => `<@${id}>`).join(" ")}`,
 		cardApproversRefusal: "這張核准卡是給提出這一輪的發話者的。",
-		cardAskerNote: (userId: string) => `-# 可以回答的人：<@${userId}>`,
+		cardAskerNote: (...userIds: readonly string[]) =>
+			`-# 可以回答的人：${userIds.map((id) => `<@${id}>`).join(" ")}`,
 		cardAskerRefusal: "這張問題是問另一位發話者的。",
 		cardInactive: `這張卡片已經失效（逾時，或 ${ctx.assistant} 重新啟動過）；需要的話直接打字回覆。`,
 		cardApproved: "✅ 已核准執行。",