@zhin.js/command 1.1.17 → 1.2.1

package/src/execution-policy.ts

@@ -1,39 +0,0 @@
-/** Optional per-capability budget, isolated by sender and the complete conversation identity. */
-export interface CommandExecutionPolicy {
-  readonly cooldownMs?: number;
-  readonly maxConcurrent?: number;
-  /** One best-effort progress message while business logic is waiting; disabled by default. */
-  readonly progressAfterMs?: number;
-}
-
-export interface CommandExecutionLimit {
-  readonly reason: 'cooldown' | 'busy' | 'capacity' | 'operation_unavailable' | 'identity_unavailable' | 'service_unavailable';
-  /** Exact remaining cooldown; a busy operation has no predictable completion time. */
-  readonly retryAfterMs?: number;
-}
-
-export class CommandExecutionLimitedError extends Error {
-  readonly limit: CommandExecutionLimit;
-  constructor(limit: CommandExecutionLimit) {
-    super(`Command execution limited: ${limit.reason}`);
-    this.name = 'CommandExecutionLimitedError';
-    this.limit = limit;
-  }
-}
-
-/** @internal Validate at declaration and projection, without coercion or silent clamping. */
-export function normalizeExecutionPolicy(value: unknown): Readonly<CommandExecutionPolicy> | undefined {
-  if (value === undefined) return undefined;
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TypeError('Command execution must be an object');
-  const limits = { cooldownMs: 86_400_000, maxConcurrent: 1000, progressAfterMs: 3_600_000 };
-  const result: Record<string, number> = {};
-  for (const [key, item] of Object.entries(value)) {
-    if (!Object.hasOwn(limits, key) || !Number.isSafeInteger(item) || (item as number) <= 0
-      || (item as number) > limits[key as keyof typeof limits]) {
-      throw new TypeError(`Command execution.${key} must be a positive bounded integer`);
-    }
-    result[key] = item as number;
-  }
-  if (Object.keys(result).length === 0) throw new TypeError('Command execution requires at least one policy');
-  return Object.freeze(result);
-}

package/src/execution-runtime.ts

@@ -1,202 +0,0 @@
-/** Internal composition contract. Not part of the command authoring facade. */
-import { createToken, type PluginId, type RuntimeSnapshot } from '@zhin.js/plugin-runtime';
-import type { CommandExecutionLimit, CommandExecutionPolicy } from './execution-policy.js';
-
-interface ConversationIdentity {
-  readonly endpoint: { readonly adapter: string; readonly id: string };
-  readonly kind: string;
-  readonly id: string;
-  readonly parent?: { readonly kind: string; readonly id: string };
-  readonly threadId?: string;
-}
-
-interface AdmissionReader {
-  admit(source: unknown, capability: string, owner: PluginId, policy: CommandExecutionPolicy, snapshot: RuntimeSnapshot): CommandExecutionLimit | undefined;
-  /**
-   * Programmatic call with no inbound source (e.g. `CommandIndex.execute`). The policy is keyed by command only:
-   * there is no sender or conversation to budget, and no reply channel for progress feedback.
-   * On success the caller must invoke `release` once the execution settles.
-   */
-  admitDirect(capability: string, policy: CommandExecutionPolicy): DirectAdmission;
-}
-
-type DirectAdmission = { readonly limit: CommandExecutionLimit; readonly release?: undefined } | { readonly limit?: undefined; readonly release: () => void };
-
-/** @internal Admission-only Root resource; no bind or finish authority is published. */
-export const commandExecutionAdmissionToken = createToken<AdmissionReader>('zhin.command.execution-admission');
-
-/** @internal Held only by Core's actual leased operation. */
-export interface CommandOperationController {
-  bind(view: object, owner: PluginId): void;
-  /** Core registers actual started delivery promises, never a caller-supplied completion callback. */
-  trackSend(send: Promise<unknown>): void;
-  /** Stop pending feedback and drain already-started feedback before the final reply. */
-  stopProgress(): Promise<void>;
-  /** Called only by the real outer operation's finally, after all final sends settle. */
-  finish(): Promise<void>;
-}
-
-interface Entry { active: number; cooldownUntil: number }
-interface Operation {
-  snapshot?: RuntimeSnapshot;
-  key?: readonly string[];
-  active: boolean;
-  progressStopped: boolean;
-  admitted: boolean;
-  signal: AbortSignal;
-  reply?: (owner: PluginId, text: string) => Promise<unknown>;
-  readonly releases: (() => void)[];
-  readonly timers: Set<ReturnType<typeof setTimeout>>;
-  readonly feedback: Promise<void>[];
-  readonly accepted: Set<string>;
-  readonly sends: Set<Promise<void>>;
-}
-
-/** @internal Root-instance-owned state shared by projections and draining retired generations. */
-export class CommandExecutionBudget {
-  readonly #entries = new Map<string, Entry>();
-  readonly #views = new WeakMap<object, { operation: Operation; owner: PluginId }>();
-  readonly #clock: () => number;
-  readonly #capacity: number;
-  readonly admission: AdmissionReader;
-
-  constructor(options: { readonly clock?: () => number; readonly capacity?: number } = {}) {
-    this.#clock = options.clock ?? (() => performance.now());
-    this.#capacity = options.capacity ?? 10_000;
-    if (!Number.isSafeInteger(this.#capacity) || this.#capacity < 1) throw new TypeError('Invalid command budget capacity');
-    this.admission = Object.freeze<AdmissionReader>({ admit: (source, capability, owner, policy, snapshot) => this.#admit(source, capability, owner, policy, snapshot),
-      admitDirect: (capability, policy) => this.#admitDirect(capability, policy) });
-  }
-
-  openOperation(input: {
-    readonly snapshot: RuntimeSnapshot;
-    readonly conversation: ConversationIdentity;
-    readonly senderId?: string;
-    readonly retirementSignal: AbortSignal;
-    readonly reply: (owner: PluginId, text: string) => Promise<unknown>;
-  }): CommandOperationController {
-    const c = input.conversation;
-    const values = [c.endpoint.adapter, c.endpoint.id, c.kind, c.id, c.parent?.kind ?? '', c.parent?.id ?? '', c.threadId ?? '', input.senderId ?? ''];
-    const valid = values.slice(0, 4).every(nonempty) && ['private', 'group', 'channel'].includes(c.kind) && nonempty(input.senderId)
-      && (c.parent === undefined || (nonempty(c.parent.kind) && nonempty(c.parent.id)))
-      && (c.threadId === undefined || nonempty(c.threadId)) && values.every(value => value.length <= 1024);
-    const operation: Operation = {
-      snapshot: input.snapshot, key: valid ? Object.freeze(values) : undefined,
-      active: true, progressStopped: false, admitted: false, signal: input.retirementSignal,
-      reply: input.reply, releases: [], timers: new Set(), feedback: [], accepted: new Set(), sends: new Set(),
-    };
-    const stop = () => {
-      operation.progressStopped = true;
-      for (const timer of operation.timers) clearTimeout(timer);
-      operation.timers.clear();
-    };
-    input.retirementSignal.addEventListener('abort', stop, { once: true });
-    return Object.freeze({
-      bind: (view: object, owner: PluginId) => { if (operation.active) this.#views.set(view, { operation, owner }); },
-      trackSend: (send: Promise<unknown>) => {
-        if (!operation.active) return;
-        const settled = send.then(() => { operation.sends.delete(settled); }, () => { operation.sends.delete(settled); });
-        operation.sends.add(settled);
-      },
-      stopProgress: async () => { stop(); await Promise.all(operation.feedback); },
-      finish: async () => {
-        stop();
-        await Promise.all(operation.feedback);
-        // New sends may start while an earlier send is draining. Do not release from an initial snapshot alone.
-        if (operation.admitted) while (operation.sends.size > 0) await Promise.all(operation.sends);
-        if (!operation.active) return;
-        operation.active = false;
-        operation.signal.removeEventListener('abort', stop);
-        for (const release of operation.releases) release();
-        operation.releases.length = 0;
-        operation.feedback.length = 0;
-        operation.accepted.clear();
-        operation.sends.clear();
-        operation.reply = undefined;
-        operation.snapshot = undefined;
-        operation.key = undefined;
-      },
-    });
-  }
-
-  #admitDirect(capability: string, policy: CommandExecutionPolicy): DirectAdmission {
-    return this.#acquire(JSON.stringify([capability, 'direct']), policy);
-  }
-
-  /** Shared entry accounting: concurrency, cooldown and capacity. Returns a one-shot release on success. */
-  #acquire(key: string, policy: CommandExecutionPolicy): DirectAdmission {
-    const now = this.#clock();
-    let entry = this.#entries.get(key);
-    if (entry && policy.maxConcurrent !== undefined && entry.active >= policy.maxConcurrent) return { limit: limited('busy') };
-    if (entry && entry.cooldownUntil > now) return { limit: Object.freeze({ reason: 'cooldown', retryAfterMs: Math.ceil(entry.cooldownUntil - now) }) };
-    if (!entry) {
-      if (this.#entries.size >= this.#capacity) {
-        for (const [oldKey, old] of this.#entries) if (old.active === 0 && old.cooldownUntil <= now) this.#entries.delete(oldKey);
-        if (this.#entries.size >= this.#capacity) {
-          // Still full of cooling identities: drop the oldest idle one. Forgetting a cooldown is acceptable;
-          // refusing every new identity is not. Only entries with running operations are never evicted.
-          for (const [oldKey, old] of this.#entries) if (old.active === 0) { this.#entries.delete(oldKey); break; }
-        }
-        if (this.#entries.size >= this.#capacity) return { limit: limited('capacity') };
-      }
-      entry = { active: 0, cooldownUntil: 0 };
-      this.#entries.set(key, entry);
-    }
-    entry.active++;
-    entry.cooldownUntil = now + (policy.cooldownMs ?? 0);
-    const acceptedEntry = entry;
-    let released = false;
-    return {
-      release: () => {
-        if (released) return;
-        released = true;
-        acceptedEntry.active--;
-        if (acceptedEntry.active === 0 && acceptedEntry.cooldownUntil <= this.#clock()) this.#entries.delete(key);
-      },
-    };
-  }
-
-  #admit(source: unknown, capability: string, owner: PluginId, policy: CommandExecutionPolicy, snapshot: RuntimeSnapshot): CommandExecutionLimit | undefined {
-    const binding = source !== null && typeof source === 'object' ? this.#views.get(source) : undefined;
-    const operation = binding?.operation;
-    if (!operation?.active || operation.snapshot !== snapshot || binding?.owner !== owner || operation.signal.aborted) return limited('operation_unavailable');
-    if (!operation.key) return limited('identity_unavailable');
-    const key = JSON.stringify([capability, ...operation.key]);
-    // Re-entering the same capability is a second attempt, rather than a second free execution.
-    const acquired = this.#acquire(key, policy);
-    if (acquired.limit) return acquired.limit;
-    operation.admitted = true;
-    operation.releases.push(acquired.release);
-    if (policy.progressAfterMs !== undefined && !operation.progressStopped && !operation.accepted.has(capability)) {
-      const timer = setTimeout(() => {
-        operation.timers.delete(timer);
-        if (!operation.active || operation.progressStopped || operation.signal.aborted || !operation.reply) return;
-        // Observe failure once. Never retry uncertain delivery and never expose the exception.
-        let send: Promise<void>;
-        try { send = Promise.resolve(operation.reply(owner, '正在处理中，请稍候。')).then(() => {}, () => {}); }
-        catch { send = Promise.resolve(); }
-        operation.feedback.push(send);
-      }, policy.progressAfterMs);
-      operation.timers.add(timer);
-    }
-    operation.accepted.add(capability);
-    return undefined;
-  }
-}
-
-function nonempty(value: unknown): value is string { return typeof value === 'string' && value.length > 0; }
-function limited(reason: CommandExecutionLimit['reason']): CommandExecutionLimit { return Object.freeze({ reason }); }
-
-/** @internal Projection reads the Root resource; ordinary authoring values cannot bind an operation. */
-export function admitCommandExecution(source: unknown, capability: string, owner: PluginId, policy: CommandExecutionPolicy | undefined, snapshot: RuntimeSnapshot): CommandExecutionLimit | undefined {
-  if (!policy) return undefined;
-  const reader = snapshot.resources.get(snapshot.root)?.get(commandExecutionAdmissionToken.id) as AdmissionReader | undefined;
-  return reader ? reader.admit(source, capability, owner, policy, snapshot) : limited('service_unavailable');
-}
-
-/** @internal Programmatic (source-less) admission: keyed by command only, never refused for lacking a source. */
-export function admitDirectCommandExecution(capability: string, policy: CommandExecutionPolicy | undefined, snapshot: RuntimeSnapshot): DirectAdmission {
-  if (!policy) return { release: () => {} };
-  const reader = snapshot.resources.get(snapshot.root)?.get(commandExecutionAdmissionToken.id) as AdmissionReader | undefined;
-  return reader ? reader.admitDirect(capability, policy) : { limit: limited('service_unavailable') };
-}

package/src/index.ts

@@ -1,31 +0,0 @@
-/**
- * Command authoring contracts, parameter schemas, and permit helpers.
- * @module @zhin.js/command
- */
-/** @internal Runtime command projection. */
-export * from './command-index.js';
-/** @public Command authoring contract and `defineCommand`. */
-export * from './definition.js';
-export * from './permission-explanation.js';
-export {
-  CONVERSATION_MANAGER_PERMIT,
-  canManageConversation,
-  assertBuiltinPermits,
-  checkBuiltinPermit,
-  checkBuiltinPermitList,
-  isBuiltinPermit,
-  isPlatformPermit,
-  parsePermitName,
-  type ParsedPermit,
-  type PermitKind,
-} from './permit.js';
-export {
-  bindCommandSource,
-  CommandPathSyntaxError,
-  commandFeatureId,
-  type BoundCommandSource,
-  default as commandFeature,
-} from './provider.js';
-export { default } from './provider.js';
-
-export type { CommandValidationIssue, CommandValidationIssueCode } from './arguments.js';

package/src/messages.ts

@@ -1,63 +0,0 @@
-import { createMessages, type Locale } from '@zhin.js/plugin-runtime';
-
-/** Translates only display metadata explicitly supplied by its author. */
-export function commandDescription(
-  value: Readonly<{ description?: string; descriptionI18n?: Readonly<Partial<Record<Locale, string>>> }>,
-  locale: Locale,
-): string | undefined {
-  return value.descriptionI18n?.[locale] ?? value.description;
-}
-
-/** Static dictionaries; the caller supplies the operation's language. */
-export const commandMessages = createMessages({
-  menuKeyword: { 'zh-CN': '菜单', en: 'menu' },
-  invalidPage: { 'zh-CN': '页码必须是正整数。用法：{command} [插件名] --page <页码>', en: 'The page must be a positive integer. Usage: {command} [plugin] --page <page>' },
-  missingPlugin: { 'zh-CN': '未找到插件: {plugin}', en: 'Plugin not found: {plugin}' },
-  pageOutOfRange: { 'zh-CN': '页码超出范围：共 {pages} 页。请使用「{command} --page <页码>」。', en: 'Page out of range: {pages} pages available. Use {command} --page <page>.' },
-  menuTitle: { 'zh-CN': '=== {plugin} 指令菜单 ===', en: '=== {plugin} command menu ===' },
-  menuSummary: { 'zh-CN': '第 {page}/{pages} 页 · {commands} 条指令 · {plugins} 个子插件', en: 'Page {page}/{pages} · Commands: {commands} · Plugins: {plugins}' },
-  childPlugins: { 'zh-CN': '子插件：', en: 'Plugins:' },
-  emptyMenu: { 'zh-CN': '（暂无指令和子插件）', en: '(No commands or plugins)' },
-  pluginHint: { 'zh-CN': '提示：使用「{command} <插件名>」查看子插件的指令', en: 'Use {command} <plugin> to view a plugin’s commands.' },
-  previousPage: { 'zh-CN': '上一页：{command}', en: 'Previous page: {command}' },
-  nextPage: { 'zh-CN': '下一页：{command}', en: 'Next page: {command}' },
-  guideTitle: { 'zh-CN': '{title} · 指令指南', en: '{title} · Command guide' },
-  guideSubtitle: { 'zh-CN': '每一个灵感，都有回应。', en: 'An answer to every idea.' },
-  commandCount: { 'zh-CN': '{count} 条指令', en: 'Commands: {count}' },
-  pluginCount: { 'zh-CN': '{count} 个子插件', en: 'Plugins: {count}' },
-  commandIndex: { 'zh-CN': '指令索引', en: 'Commands' },
-  pluginIndex: { 'zh-CN': '插件导航', en: 'Plugins' },
-  guideEmpty: { 'zh-CN': '暂无指令和子插件', en: 'No commands or plugins' },
-  helpHint: { 'zh-CN': '查看参数与用法：{command} --help', en: 'View arguments and usage: {command} --help' },
-  genericHelpHint: { 'zh-CN': '在当前环境的指令后追加 --help 查看用法', en: 'Append --help to a command in this environment to view its usage' },
-  expectedType: { 'zh-CN': '{field}：应为 {type}', en: '{field}: expected {type}' },
-  expectedArray: { 'zh-CN': '{field}：应为 {type} 数组', en: '{field}: expected an array of {type}' },
-  minimum: { 'zh-CN': '{field}：最小值为 {minimum}', en: '{field}: minimum {minimum}' },
-  maximum: { 'zh-CN': '{field}：最大值为 {maximum}', en: '{field}: maximum {maximum}' },
-  choices: { 'zh-CN': '{field}：可选值为 {choices}', en: '{field}: expected one of {choices}' },
-  invalidFormat: { 'zh-CN': '{field}：格式不正确', en: '{field}: invalid format' },
-  invalidValue: { 'zh-CN': '{field}：值不正确', en: '{field}: invalid value' },
-  unknownOption: { 'zh-CN': '未知选项 {field}', en: 'Unknown option {field}' },
-  duplicateOption: { 'zh-CN': '重复选项 --{field}', en: 'Duplicate option --{field}' },
-  defaultUndefined: { 'zh-CN': '{field}：默认值返回了 undefined', en: '{field}: default returned undefined' },
-  parameterUndefined: { 'zh-CN': '{field}：默认值或快捷指令返回了 undefined', en: '{field}: default or shortcut returned undefined' },
-  missingOption: { 'zh-CN': '缺少选项 --{field}', en: 'Missing option --{field}' },
-  missingRequiredParam: { 'zh-CN': '缺少必填参数 {field}（类型：{type}）', en: 'Missing required parameter {field} (expected {type})' },
-  unexpectedArguments: { 'zh-CN': '存在多余参数', en: 'Unexpected arguments' },
-  invalidParameter: { 'zh-CN': '缺少指令参数或参数不正确', en: 'Missing or invalid command parameter' },
-  defaultValue: { 'zh-CN': '默认值：{value}', en: 'default: {value}' },
-  dynamicValue: { 'zh-CN': '动态计算', en: 'dynamic' },
-  noAdapter: { 'zh-CN': '命令未声明 adapter 约束', en: 'The command does not declare an adapter restriction' },
-  missingEndpoint: { 'zh-CN': '未选择当前 Endpoint，无法判断命令的精确 adapter 约束', en: 'Select an Endpoint to evaluate the command’s exact adapter restriction' },
-  adapterComparison: { 'zh-CN': '命令 adapter 与当前 Endpoint 声明的原生适配器精确比较；未探测在线状态', en: 'Exact comparison with the Endpoint’s declared native adapter; online status was not checked' },
-  conditionMismatch: { 'zh-CN': '至少一个声明条件与假设输入不符；这不是实际准入检查', en: 'At least one declared condition does not match the hypothetical input; this is not a live admission check' },
-  missingPermissionHost: { 'zh-CN': 'PermissionHost 缺失或无法确认；不能推断命令可执行', en: 'PermissionHost is missing or unverified; command execution cannot be inferred' },
-  missingEvidence: { 'zh-CN': '存在缺少依据的条件，不能推断命令可执行', en: 'Some conditions lack evidence; command execution cannot be inferred' },
-  noPermit: { 'zh-CN': '命令未声明 permit 限制；这不表示已获得执行权限', en: 'The command does not declare permit restrictions; this does not establish authorization' },
-  uncheckedConditions: { 'zh-CN': '存在未执行的平台或自定义条件，不能推断命令可执行', en: 'Platform or custom conditions have not been evaluated; command execution cannot be inferred' },
-  conditionsMatch: { 'zh-CN': '已解释的 builtin 条件与假设输入匹配；不代表真实授权或命令可执行', en: 'The explained builtin conditions match the hypothetical input; this does not establish authorization or executability' },
-  unconstrained: { 'zh-CN': '已解释的 builtin 规则不检查具体 Endpoint、parent 或 thread；保留完整目标不等于这些维度受规则限制', en: 'The explained builtin rules do not constrain a specific Endpoint, parent or thread; retaining the full target does not add such restrictions' },
-  simulatedIdentity: { 'zh-CN': '身份与角色仅用于模拟，未向平台核实', en: 'Identity and roles are hypothetical and have not been verified with the platform' },
-  unevaluatedCode: { 'zh-CN': '未执行命令、动态默认值、平台或自定义 checker', en: 'Commands, dynamic defaults, platform checks and custom checkers have not been executed' },
-  defaultedRole: { 'zh-CN': 'canonical 输入未附角色时按命令运行时默认 user 解释；这不是已核验的平台角色', en: 'Canonical input without roles uses the command runtime’s default user role; this is not a verified platform role' },
-});

package/src/permission-explanation.ts

@@ -1,61 +0,0 @@
-import { operationClientAdapter } from '@zhin.js/feature-kit';
-import { explainPermitRules, toPermissionSubject, type PermissionSubject, type PermissionConditionExplanation } from '@zhin.js/permission';
-import { resolveCommandSender, resolveCommandSession, type CommandMessage } from './definition.js';
-import type { CommandDescriptor } from './command-index.js';
-import { resolveLocale, type Locale } from '@zhin.js/plugin-runtime';
-import { commandMessages } from './messages.js';
-
-/** The exact subject projection used by the real command permit gate. No factories or checkers run. */
-export function toCommandPermissionSubject(source: unknown): PermissionSubject {
-  const projected = toPermissionSubject(source);
-  const session = resolveCommandSession(source);
-  return { ...projected, ...session, ...(session.sender ? { sender: { ...projected.sender, ...session.sender } } : {}) };
-}
-
-/** Exact authoring adapter restriction, distinct from builtin adapter(...) matching. */
-export function commandAdapterMatches(command: Readonly<{ adapter?: string }>, source: unknown): boolean {
-  return !command.adapter || operationClientAdapter(source) === command.adapter;
-}
-
-export type CommandPermissionHostStatus = 'present' | 'missing' | 'unverified';
-
-/** Read-only hypothetical conditions. A match is not permission to execute the command. */
-export function explainCommandPermissions(
-  command: Pick<CommandDescriptor, 'adapter' | 'permit'>,
-  options: Readonly<{ source?: unknown; rolesKnown?: boolean; permissionHost: CommandPermissionHostStatus; locale?: Locale }>,
-) {
-  const locale = resolveLocale(options.locale);
-  const projected = toCommandPermissionSubject(options.source);
-  const inputSender = options.source && typeof options.source === 'object'
-    ? (options.source as Pick<CommandMessage, 'sender'>).sender : undefined;
-  const structuredRoles = inputSender && typeof inputSender === 'object'
-    && Array.isArray((inputSender as { readonly role?: unknown }).role);
-  // A sender-only assumption has no synthetic conversation. Apply the real canonical
-  // sender defaults without inventing an Endpoint or treating unknown roles as known.
-  const senderOnly = options.source && typeof options.source === 'object' && !('conversation' in options.source) && !structuredRoles
-    ? resolveCommandSender(options.source as Pick<CommandMessage, 'sender'>, undefined) : undefined;
-  const subject = senderOnly ? { ...projected, sender: senderOnly } : projected;
-  const defaultedRoles = options.rolesKnown && Array.isArray(inputSender?.roles) && inputSender.roles.length === 0
-    && subject.sender?.role.length === 1 && subject.sender.role[0] === 'user';
-  const actualAdapter = operationClientAdapter(options.source);
-  const adapter: PermissionConditionExplanation = !command.adapter
-    ? { outcome: 'not_evaluated', reason: commandMessages(locale, 'noAdapter') }
-    : !actualAdapter ? { outcome: 'unknown', reason: commandMessages(locale, 'missingEndpoint') }
-      : { outcome: commandAdapterMatches(command, options.source) ? 'match' : 'mismatch', reason: commandMessages(locale, 'adapterComparison') };
-  const rules = explainPermitRules(command.permit ?? [], subject, { rolesKnown: options.rolesKnown, locale });
-  const conditions = [...(command.adapter ? [adapter] : []), ...rules];
-  let summary: PermissionConditionExplanation;
-  if (conditions.some(item => item.outcome === 'mismatch')) summary = { outcome: 'mismatch', reason: commandMessages(locale, 'conditionMismatch') };
-  else if ((rules.length > 0 && options.permissionHost !== 'present') || conditions.some(item => item.outcome === 'unknown')) {
-    summary = { outcome: 'unknown', reason: rules.length > 0 && options.permissionHost !== 'present'
-      ? commandMessages(locale, 'missingPermissionHost') : commandMessages(locale, 'missingEvidence') };
-  } else if (rules.length === 0) summary = { outcome: 'not_evaluated', reason: commandMessages(locale, 'noPermit') };
-  else if (conditions.some(item => item.outcome === 'not_evaluated')) summary = { outcome: 'not_evaluated', reason: commandMessages(locale, 'uncheckedConditions') };
-  else summary = { outcome: 'match', reason: commandMessages(locale, 'conditionsMatch') };
-  return Object.freeze({ permissionHost: options.permissionHost, adapter: Object.freeze(adapter), rules, summary: Object.freeze(summary),
-    unconstrained: Object.freeze([commandMessages(locale, 'unconstrained')]),
-    assumptions: Object.freeze([commandMessages(locale, 'simulatedIdentity'), commandMessages(locale, 'unevaluatedCode'),
-      ...(defaultedRoles
-        ? [commandMessages(locale, 'defaultedRole')] : [])]),
-  });
-}

package/src/permit.ts

@@ -1,28 +0,0 @@
-/**
- * Re-export permit 解析/校验 from @zhin.js/permission (SSOT)。
- * 保留 CommandSession 兼容签名供 command-index 过渡使用。
- */
-import { checkBuiltinPermit, type PermissionSubject } from '@zhin.js/permission';
-
-/** 会话管理者：群主 / 群管理员 / 机器人主人（适配器投影的规范角色名）。 */
-export const CONVERSATION_MANAGER_PERMIT = 'role(owner,admin,master)';
-
-/**
- * 「私聊，或 owner / admin / master」。`permit` 列表只支持 AND，
- * 订阅类命令需要这个 OR 规则时用它，并以命令会话的 `scene` / `sender.role` 为输入。
- */
-export function canManageConversation(subject: PermissionSubject): boolean {
-  return checkBuiltinPermit('private()', subject)
-    || checkBuiltinPermit(CONVERSATION_MANAGER_PERMIT, subject);
-}
-
-export {
-  type PermitKind,
-  type ParsedPermit,
-  parsePermitName,
-  isBuiltinPermit,
-  isPlatformPermit,
-  assertPermitSyntax as assertBuiltinPermits,
-  checkBuiltinPermit,
-  checkBuiltinPermitList,
-} from '@zhin.js/permission';