@modesto_ma/dsh-channels 0.4.0 → 0.5.0-beta.2

package/src/client/string-list.ts

@@ -0,0 +1,139 @@
+/**
+ * 浏览器半区的 `string-list` 字段辅助：把草稿值读成条目数组，并在保存前
+ * 逐项校验，供面板即时标红。Host 保存时按同一规则复核（见
+ * `settings/surface.ts` 的 `normalizeStringList`）。
+ *
+ * 不含 JSX/React，便于单测。条目格式校验直接复用纯函数模块
+ * `feishu/wiki/links.ts`（无运行时依赖，可内联进 Client bundle）。
+ *
+ * @module dsh-channels/client/string-list
+ */
+
+import { parseWikiRootLink, WIKI_ROOT_LINK_ERRORS } from '../feishu/wiki/links.ts'
+import { PANEL_COPY } from '../settings/contract.ts'
+import type {
+  ConfigValue,
+  EditableFieldWire,
+  FieldIssueWire,
+  StringListItemFormat,
+} from '../settings/contract.ts'
+
+/** Entry checks per item format: the readable reason, or `undefined` when valid. */
+const ITEM_FORMAT_CHECKS: Readonly<Record<StringListItemFormat, (entry: string) => string | undefined>> = {
+  'wiki-root-link': (entry) => {
+    const parsed = parseWikiRootLink(entry)
+    return parsed.ok ? undefined : WIKI_ROOT_LINK_ERRORS[parsed.error]
+  },
+}
+
+/**
+ * Entries of a `string-list` value; any other value reads as no entries.
+ *
+ * @param value - Draft or effective value of a `string-list` field.
+ * @returns The entries as stored (untrimmed).
+ */
+export function listItems(value: ConfigValue | undefined): readonly string[] {
+  return typeof value === 'object' ? value : []
+}
+
+/**
+ * Validate the entries of one `string-list` draft the way the Host will:
+ * empty inputs are ignored, every other entry is trimmed and checked against
+ * the field's `itemFormat`, and the non-empty count is bounded by `maxItems`.
+ *
+ * @param field - The Host descriptor (`kind: 'string-list'`).
+ * @param items - The draft entries, empty inputs included.
+ * @returns Per-entry issues (with `index` into `items`) and a whole-field issue when over `maxItems`.
+ */
+export function stringListIssues(field: EditableFieldWire, items: readonly string[]): FieldIssueWire[] {
+  const issues: FieldIssueWire[] = []
+  const check = field.itemFormat === undefined ? undefined : ITEM_FORMAT_CHECKS[field.itemFormat]
+  let count = 0
+  items.forEach((item, index) => {
+    const entry = item.trim()
+    if (entry === '') return
+    count += 1
+    const reason = check?.(entry)
+    if (reason === undefined) return
+    const position = PANEL_COPY.listEntry.replace('{n}', String(index + 1))
+    issues.push({ key: field.key, index, message: `${position}「${entry}」：${reason}` })
+  })
+  if (field.maxItems !== undefined && count > field.maxItems) {
+    issues.push({ key: field.key, message: PANEL_COPY.listTooMany.replace('{max}', String(field.maxItems)) })
+  }
+  return issues
+}
+
+/**
+ * Turn one `string-list` draft into its save payload. Entries are submitted as
+ * typed (untrimmed, empty inputs included) so Host issue indexes point at the
+ * same rendered inputs; the Host trims and drops empty inputs.
+ *
+ * @param field - The Host descriptor (`kind: 'string-list'`).
+ * @param raw - The draft value.
+ * @returns The payload entries, or the issues that block the save.
+ */
+export function stringListDraftValue(
+  field: EditableFieldWire,
+  raw: ConfigValue | undefined,
+): { ok: true; value: string[] } | { ok: false; issues: FieldIssueWire[] } {
+  const items = listItems(raw)
+  const issues = stringListIssues(field, items)
+  return issues.length > 0 ? { ok: false, issues } : { ok: true, value: [...items] }
+}
+
+/**
+ * Inputs the list control renders: one per entry, or one blank input for an
+ * empty list so the first entry can be typed directly.
+ *
+ * @param value - Draft or effective value.
+ * @returns The input values, in order.
+ */
+export function listRows(value: ConfigValue | undefined): readonly string[] {
+  const items = listItems(value)
+  return items.length === 0 ? [''] : items
+}
+
+/**
+ * Replace the entry at one input position.
+ *
+ * @param rows - Rendered inputs ({@link listRows}).
+ * @param index - Position of the edited input.
+ * @param entry - The typed value.
+ * @returns The next draft entries.
+ */
+export function withListEntry(rows: readonly string[], index: number, entry: string): string[] {
+  return rows.map((item, position) => (position === index ? entry : item))
+}
+
+/**
+ * Drop the entry at one input position.
+ *
+ * @param rows - Rendered inputs ({@link listRows}).
+ * @param index - Position of the removed input.
+ * @returns The next draft entries.
+ */
+export function withoutListEntry(rows: readonly string[], index: number): string[] {
+  return rows.filter((_, position) => position !== index)
+}
+
+/**
+ * Append one blank input.
+ *
+ * @param rows - Rendered inputs ({@link listRows}).
+ * @returns The next draft entries.
+ */
+export function withBlankListEntry(rows: readonly string[]): string[] {
+  return [...rows, '']
+}
+
+/**
+ * Whether the add button is disabled: the inputs already reach `maxItems`.
+ *
+ * @param field - The Host descriptor.
+ * @param rows - Rendered inputs ({@link listRows}).
+ * @returns `true` when no further input may be added.
+ */
+export function listIsFull(field: EditableFieldWire, rows: readonly string[]): boolean {
+  return field.maxItems !== undefined && rows.length >= field.maxItems
+}

package/src/client/styles.ts

@@ -59,6 +59,9 @@ const CSS = `
 .dsh-channels-cfg__inputRow{display:flex;align-items:center;gap:8px;min-width:0}
 .dsh-channels-cfg__inputRow .dsh-channels-cfg__input{flex:1 1 auto;width:auto;min-width:0}
 .dsh-channels-cfg__btn--browse{flex:none}
+.dsh-channels-cfg__list{display:flex;flex-direction:column;gap:6px;min-width:0}
+.dsh-channels-cfg__listItem{display:flex;flex-direction:column;gap:2px;min-width:0}
+.dsh-channels-cfg__btn--listRemove{flex:none}
 .dsh-channels-cfg__input:focus{border-color:var(--dsw-alias-state-business-primary,#0a67d3)}
 .dsh-channels-cfg__input--invalid{border-color:var(--dsw-alias-state-danger-primary,#c62828)}
 select.dsh-channels-cfg__input{appearance:auto;cursor:pointer}
@@ -68,6 +71,8 @@ select.dsh-channels-cfg__input{appearance:auto;cursor:pointer}
 .dsh-channels-cfg__notice{display:flex;flex-direction:column;gap:2px;padding:8px 10px;border-radius:8px;font-size:12px;line-height:18px;overflow-wrap:anywhere}
 .dsh-channels-cfg__notice--ok{color:var(--dsw-alias-state-business-primary,#0a7d33);background:color-mix(in srgb,currentColor 8%,transparent)}
 .dsh-channels-cfg__notice--error{color:var(--dsw-alias-state-danger-primary,#c62828);background:color-mix(in srgb,currentColor 8%,transparent)}
+.dsh-channels-cfg__notice a{color:inherit;text-decoration:underline}
+.dsh-channels-cfg__scopeList{margin:2px 0;padding-left:18px;display:flex;flex-direction:column;gap:2px}
 .dsh-channels-cfg__banner{display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding:8px 10px;border-radius:8px;border:1px dashed var(--dsw-alias-state-warning-primary,#a15c00);color:var(--dsw-alias-state-warning-primary,#a15c00);font-size:12px;line-height:18px}
 .dsh-channels-cfg__footer{display:flex;align-items:center;gap:8px;flex-wrap:wrap;padding-top:2px}
 .dsh-channels-cfg__spacer{flex:1}

package/src/commands/registry.ts

@@ -28,7 +28,10 @@ export interface ChannelCommandSpec {
   readonly mentionGate?: boolean
   /** Only usable in this chat type. */
   readonly chatType?: 'p2p' | 'group'
-  /** Answer with a direct reply instead of creating a topic. */
+  /**
+   * Answer with a direct reply instead of creating a topic; inside an existing
+   * topic the reply still lands in that topic.
+   */
   readonly directReply?: boolean
   /**
    * Answered by the channel itself (`/stop`), never through the agent command
@@ -47,7 +50,7 @@ export interface ChannelCommandSpec {
 export const CHANNEL_COMMANDS = [
   {
     name: 'help', group: '基础', description: '显示当前支持的斜杠命令',
-    routeFree: true, directReply: false,
+    routeFree: true, directReply: true,
   },
   {
     name: 'userid', group: '基础', description: '在私聊中显示当前用户 ID',
@@ -59,7 +62,7 @@ export const CHANNEL_COMMANDS = [
   },
   {
     name: 'health', group: '基础', description: '显示 Harness 与飞书通道健康状态',
-    sessionOptional: true,
+    sessionOptional: true, directReply: true,
   },
   {
     name: 'status', group: '会话', description: '显示当前 Session 状态与性能指标',
@@ -72,8 +75,8 @@ export const CHANNEL_COMMANDS = [
     usage: '[name]', channelPlane: true, agentScoped: false,
   },
   {
-    name: 'auth', group: '会话', description: '查看/管理访问授权（仅管理员）',
-    usage: '[status|allow|revoke|list|user add <open_id>|user remove <open_id>]',
+    name: 'auth', group: '会话', description: '查看/管理访问授权，可 @ 成员授权（仅管理员）',
+    usage: '[status|allow|revoke|list|user add <@用户|user_id>|user remove <@用户|user_id>]',
     routeFree: true, channelPlane: true, agentScoped: false,
   },
   {

package/src/config.ts

@@ -13,7 +13,8 @@
  */
 
 import { z } from 'zod'
-import { WORKSPACE_RETENTION_VALUES } from './cleanup.ts'
+import { FEISHU_USER_ID_PATTERN } from './domain.ts'
+import { parseWikiRootLink, WIKI_ROOT_LINK_ERRORS } from './feishu/wiki/links.ts'
 
 export const FEISHU_LOGGER_LEVELS = ['debug', 'info', 'warn', 'error'] as const
 export type FeishuLoggerLevel = (typeof FEISHU_LOGGER_LEVELS)[number]
@@ -38,12 +39,6 @@ export const DEFAULT_QUESTION_TIMEOUT_MS = 5 * 60 * 1000
 export const ATTACHMENT_STORE_MODES = ['native', 'archive'] as const
 export type AttachmentStoreMode = (typeof ATTACHMENT_STORE_MODES)[number]
 
-/** Default retention of silently registered attachment metadata: 7 days. */
-export const DEFAULT_PENDING_ATTACHMENT_TTL_MS = 7 * 24 * 60 * 60 * 1000
-
-/** Default per-`(chat, thread, sender)` cap of pending attachment rows. */
-export const DEFAULT_PENDING_ATTACHMENT_LIMIT = 10
-
 /** Default per-call attachment count of `feishu_attachment_fetch`. */
 export const DEFAULT_ATTACHMENT_FETCH_MAX_RESOURCES = 10
 
@@ -103,13 +98,6 @@ export const configSchema = z.object({
    * against the host process cwd.
    */
   baseDir: z.string().min(1).default('./channels-data'),
-  /**
-   * Optional path of the Web settings overlay (default
-   * `$DSH_HOME/dsh-channels/settings.json`). The Web panel writes only
-   * editable fields there; this path is for embedded hosts, tests, or users
-   * who want multiple instances with different overlays.
-   */
-  settingsFile: z.string().min(1).optional(),
   /** LLM provider route for sessions this plugin creates (optional → deployment default). */
   provider: z.string().optional(),
   /** Model id for sessions this plugin creates (optional → deployment default). */
@@ -193,7 +181,7 @@ export const configSchema = z.object({
    * behind a prompt manifest; with the archive backend the resources are saved
    * below `<workspace>/attachments/` before the turn, exactly like the legacy
    * pipeline. Disabled keeps attachment messages inert (no save, no turn, no
-   * pending metadata registration).
+   * manifest rows).
    */
   acceptAttachments: z.boolean().default(true),
   /**
@@ -263,24 +251,6 @@ export const configSchema = z.object({
    */
   promptContextTimeoutMs: z.number().int().min(100).max(10_000)
     .default(DEFAULT_PROMPT_CONTEXT_TIMEOUT_MS),
-  /**
-   * Retention of silently registered attachment metadata (the
-   * `pending_attachments` table). A message that does not trigger a model turn
-   * (attachment-only p2p message, un-mentioned group message, attachment-only
-   * message inside a bound topic) is recorded as metadata only; a later
-   * triggered message in the same `(chat, thread, sender)` scope may list and
-   * fetch it. Rows older than this window are removed by the periodic record
-   * GC. `0` disables age pruning (the per-scope cap still bounds each scope).
-   * Default 7 days.
-   */
-  pendingAttachmentTtlMs: z.number().int().min(0).default(DEFAULT_PENDING_ATTACHMENT_TTL_MS),
-  /**
-   * Maximum silently registered attachment rows kept per `(chat, thread,
-   * sender)` scope. Registering beyond the cap evicts the oldest row of that
-   * scope; the prompt manifest only ever shows the most recent 5 unconsumed
-   * rows. Default 10.
-   */
-  pendingAttachmentLimit: z.number().int().min(1).max(100).default(DEFAULT_PENDING_ATTACHMENT_LIMIT),
   /**
    * Model-facing Feishu tools.
    *
@@ -312,6 +282,26 @@ export const configSchema = z.object({
    * - `topicMessagesTimeoutMs`: whole-call timeout of one model-initiated
    *   topic read (default 20 s). Passive prompt excerpts use a separate short
    *   (~3 s) budget and never wait this long.
+   * - `sendFile` (default on): register `feishu_send_file` in channel sessions
+   *   so the model can send an image or file from the topic's working
+   *   directory back to the current conversation. Needs the Feishu
+   *   `im:resource` (or `im:resource:upload`) scope; without it a call returns
+   *   a readable failure and the turn continues.
+   *
+   * - `wikiRead` (default off): register `feishu_wiki_list` and
+   *   `feishu_wiki_read` so the model can browse the wiki nodes under
+   *   `wikiRoots` and read docx documents there. Needs `wiki:wiki` (or
+   *   `wiki:wiki:readonly`) and `docx:document` (or `docx:document:readonly`).
+   * - `wikiWrite` (default off): register `feishu_wiki_create` and
+   *   `feishu_wiki_edit` so the model can create docx documents under
+   *   `wikiRoots` and edit documents this app owns. Needs `wiki:wiki` and
+   *   `docx:document`.
+   *
+   * The wiki tools act with the app identity and are mounted only while
+   * `wikiRoots` is non-empty. Each call is limited to topics whose owner is
+   * the administrator or on the wiki whitelist (`/auth wiki add`); opening a
+   * document, creating one, and editing one each need the topic owner's
+   * consent on an authorization card (a read consent lasts for the topic).
    *
    * The Web panel/metrics ship with `panel_docs_release`.
    */
@@ -326,6 +316,9 @@ export const configSchema = z.object({
     topicMessages: z.boolean().default(true),
     topicMessagesTimeoutMs: z.number().int().min(1_000).max(120_000)
       .default(DEFAULT_TOPIC_MESSAGES_TIMEOUT_MS),
+    sendFile: z.boolean().default(true),
+    wikiRead: z.boolean().default(false),
+    wikiWrite: z.boolean().default(false),
   }).default({
     attachmentFetch: true,
     attachmentFetchMaxResources: DEFAULT_ATTACHMENT_FETCH_MAX_RESOURCES,
@@ -333,28 +326,34 @@ export const configSchema = z.object({
     attachmentFetchTimeoutMs: DEFAULT_ATTACHMENT_FETCH_TIMEOUT_MS,
     topicMessages: true,
     topicMessagesTimeoutMs: DEFAULT_TOPIC_MESSAGES_TIMEOUT_MS,
+    sendFile: true,
+    wikiRead: false,
+    wikiWrite: false,
   }),
   /**
-   * Delete the topic directories of stale conversations, plus legacy
-   * one-workspace-per-topic directories written by older plugin versions.
-   * `off` (default) never deletes; `7d`/`30d`/`90d`/`180d` remove those
-   * directories when their last activity is older than the threshold. User
-   * workspaces themselves are never deleted. The managed Web panel exposes
-   * this as a select, previews the candidates, and can run one cleanup
-   * manually. DSH Session logs are never deleted.
+   * Wiki (知识库) locations the wiki tools may touch: whole spaces
+   * (`https://<tenant>.feishu.cn/wiki/space/<space_id>`) or single nodes with
+   * everything below them (`https://<tenant>.feishu.cn/wiki/<node_token>`).
+   * Browsing, reading, creating, and editing outside these roots fail. Empty
+   * (default) mounts no wiki tool even when `feishuTools.wikiRead`/`wikiWrite`
+   * is on.
    */
-  workspaceRetention: z.enum(WORKSPACE_RETENTION_VALUES).default('off'),
-  /**
-   * Run the retention cleanup at startup and once per day. Off by default:
-   * deletion is irreversible, so it stays an explicit opt-in even when a
-   * retention threshold is configured.
-   */
-  workspaceRetentionAuto: z.boolean().default(false),
+  wikiRoots: z.array(z.string().trim().superRefine((link, issue) => {
+    const parsed = parseWikiRootLink(link)
+    if (!parsed.ok) issue.addIssue({ code: 'custom', message: WIKI_ROOT_LINK_ERRORS[parsed.error] })
+  })).max(20).default([]),
   /**
    * Send a one-time onboarding card on the first private message of a chat
    * (facts + command cheat sheet). Persisted per chat; never repeats.
    */
   welcomeOnboarding: z.boolean().default(true),
+  /**
+   * Sync the command registry to Feishu's native `/` panel on every connect
+   * (needs the `application:app_slash_command:read`/`write` scopes). Off by
+   * default: some tenants forbid apps from adding slash commands. When off,
+   * the plugin neither reads nor writes the panel.
+   */
+  slashCommandPanel: z.boolean().default(false),
   /**
    * Allow `/permissions <name>` to switch this Session's sandbox + approval
    * preset from Feishu. Read-only `/permissions` always works; switching is
@@ -373,15 +372,17 @@ export const configSchema = z.object({
    */
   accessMode: z.enum(['open', 'guarded']).default('guarded'),
   /**
-   * The unique administrator's Feishu open_id (`ou_...`). Set it in the Web
+   * The unique administrator's Feishu `user_id`. Set it in the Web
    * settings panel (or the profile config). Get it by sending `/userid` to the
-   * bot in a private chat. While `accessMode` is `guarded` and this is unset,
-   * every conversation is refused (fail closed); `/userid` and a fixed notice
-   * stay available so the deployment can be bootstrapped.
+   * bot in a private chat. When unset, the Feishu app owner (looked up via
+   * `application.v6.application.get` at connect; needs an app-info read scope)
+   * is the administrator. While `accessMode` is `guarded` and neither is
+   * available, every conversation is refused (fail closed); `/userid` and a
+   * fixed notice stay available so the deployment can be bootstrapped.
    */
-  adminOpenId: z.string().regex(
-    /^ou_[A-Za-z0-9_-]+$/,
-    'must be a Feishu open_id such as ou_xxx (send /userid to the bot in a private chat to see it)',
+  adminUserId: z.string().regex(
+    FEISHU_USER_ID_PATTERN,
+    'must be a Feishu user_id, not an open_id (send /userid to the bot in a private chat to see it)',
   ).optional(),
   /**
    * Lifetime of one pending authorization request and of the DM card that asks

package/src/domain.ts

@@ -41,8 +41,8 @@ export const routeRecordSchema = z.object({
   chatId: z.string().min(1),
   /** `p2p` or `group`. */
   chatType: z.enum(['p2p', 'group']),
-  /** Workspace owner (sender open_id). */
-  senderOpenId: z.string().min(1),
+  /** Workspace owner (sender user_id). */
+  senderUserId: z.string().min(1),
   /** Workspace root owning this route: the Session header cwd / sandbox root. */
   workspacePath: z.string().min(1),
   /**
@@ -81,15 +81,14 @@ export const expiredRouteRecordSchema = z.object({
   /** Original chat type, retained for diagnostics and future policy. */
   chatType: z.enum(['p2p', 'group']),
   /** Original route owner; never used to grant access after expiry. */
-  senderOpenId: z.string().min(1),
+  senderUserId: z.string().min(1),
   /** Epoch ms when the route was retired. */
   expiredAt: z.number().int().nonnegative(),
   /** Workspace the retired route belonged to; absent in tombstones written by
    *  older plugin versions, so the field must stay optional. */
   workspacePath: z.string().min(1).optional(),
   /** Effective working directory the retired route's Session used; absent in
-   *  legacy tombstones (retention cleanup then treats `workspacePath` as the
-   *  directory, matching pre-v2 routes). */
+   *  legacy tombstones, where `workspacePath` was the directory (pre-v2 routes). */
   sessionDir: z.string().min(1).optional(),
   /** Git branch of that directory when it was a worktree checkout. */
   worktreeBranch: z.string().min(1).optional(),
@@ -202,7 +201,7 @@ export const accessGroupRecordSchema = z.object({
   name: z.string().optional(),
   /** Which authorization entry produced this grant. */
   source: z.enum(['command', 'card', 'panel']),
-  /** Administrator open_id that authorized it. */
+  /** Administrator user_id that authorized it. */
   addedBy: z.string().min(1),
   /** Epoch ms when it was authorized. */
   addedAt: z.number().int().nonnegative(),
@@ -211,18 +210,18 @@ export const accessGroupRecordSchema = z.object({
 export type AccessGroupRecord = z.infer<typeof accessGroupRecordSchema>
 
 /**
- * One authorized user (`open_id`), global across every authorized group.
+ * One authorized user (`user_id`), global across every authorized group.
  * Private chats are administrator-only, so this grant only affects group
  * conversations.
  */
 export const accessUserRecordSchema = z.object({
-  /** Feishu open id (`ou_...`) — also the table key. */
-  openId: z.string().min(1),
+  /** Feishu `user_id` — also the table key. */
+  userId: z.string().min(1),
   /** Display name captured when the user was authorized (optional). */
   name: z.string().optional(),
   /** Which authorization entry produced this grant. */
   source: z.enum(['command', 'card', 'panel']),
-  /** Administrator open_id that authorized it. */
+  /** Administrator user_id that authorized it. */
   addedBy: z.string().min(1),
   /** Epoch ms when it was authorized. */
   addedAt: z.number().int().nonnegative(),
@@ -241,14 +240,14 @@ export const accessRequestRecordSchema = z.object({
   token: z.string().min(1),
   /** What is being requested. */
   kind: z.enum(['group', 'user']),
-  /** `chat_id` for a group request; `open_id` for a user request. */
+  /** `chat_id` for a group request; `user_id` for a user request. */
   targetId: z.string().min(1),
   /** Chat the request originated from, when applicable. */
   chatId: z.string().optional(),
   /** Group name captured for the card (group requests, or the group the user was seen in). */
   groupName: z.string().optional(),
   /** User who triggered a user request. */
-  requesterOpenId: z.string().optional(),
+  requesterUserId: z.string().optional(),
   /** Display name of that user, when the event carried one. */
   requesterName: z.string().optional(),
   /** Lifecycle state; only `pending` requests accept a card action. */
@@ -282,91 +281,8 @@ export const processedRecordSchema = z.object({
 
 export type ProcessedRecord = z.infer<typeof processedRecordSchema>
 
-/**
- * Silently registered inbound attachment metadata ("pending attachments").
- *
- * A message that does not trigger a model turn — a p2p attachment-only
- * message, an un-mentioned group message, an attachment-only message inside an
- * already-bound topic — is recorded here without downloading bytes, replying,
- * or reacting. A later triggered message in the same `(chat, thread?, sender)`
- * scope can list these entries in its prompt manifest and fetch them on demand
- * through the attachment tool. The table stores metadata only (Feishu resource
- * keys), never bytes.
- *
- * Added without a storage-domain version bump: the host's JSON backend loads a
- * declared table that is missing from the stored document as empty and keeps
- * the stored `unit.version` (1), so existing deployments gain the table with no
- * migration. Downgrading to a plugin build without this table would drop it on
- * the next write — acceptable because plugin builds are replaced in place.
- */
-export const PENDING_ATTACHMENT_KINDS = ['image', 'file', 'post', 'merge_forward'] as const
-
-/** Kind of message that carried the attachment payload. */
-export type PendingAttachmentKind = (typeof PENDING_ATTACHMENT_KINDS)[number]
-
-/**
- * One attachment resource inside a pending record. Feishu downloads resources
- * by `(message id, file key)`; `containerMessageId` is set when only a
- * top-level container id works (merged-forward children).
- */
-export const pendingAttachmentResourceSchema = z.object({
-  /** Resource kind delivered by Feishu. */
-  type: z.enum(['image', 'file']),
-  /** Feishu resource key (`img_v3_...` / `file_v3_...`). */
-  fileKey: z.string().min(1),
-  /** Original file name, when Feishu reports one. */
-  fileName: z.string().min(1).optional(),
-  /** Feishu folder entries cannot be downloaded; recorded so the fetch tool can
-   *  answer with a structured "folder unsupported" instead of a raw API error. */
-  folder: z.boolean().optional(),
-  /** Top-level container message id to download through, when different from
-   *  this record's own `messageId` (merged-forward child resources). */
-  containerMessageId: z.string().min(1).optional(),
-})
-
-export type PendingAttachmentResource = z.infer<typeof pendingAttachmentResourceSchema>
-
-/**
- * One silently registered attachment message. Keyed by its Feishu message id so
- * a redelivered event can never register twice. `scopeKey` is the
- * `(chat, thread?, sender)` isolation unit; `consumed` marks metadata the
- * agent already fetched, which then drops out of the prompt manifest (the
- * record stays as an authorization fact until its TTL).
- */
-export const pendingAttachmentRecordSchema = z.object({
-  /** Key the record is stored under (= `messageId`). */
-  key: z.string().min(1),
-  /** `(chat, thread?, sender)` isolation key; see `pendingAttachmentScopeKey`. */
-  scopeKey: z.string().min(1),
-  /** Feishu message id of the attachment message (the container id for
-   *  merged-forward records). */
-  messageId: z.string().min(1),
-  /** Feishu chat the message arrived in. */
-  chatId: z.string().min(1),
-  /** `p2p` or `group`. */
-  chatType: z.enum(['p2p', 'group']),
-  /** Feishu topic the message belongs to, when it has one. */
-  threadId: z.string().min(1).optional(),
-  /** Normalized sender id (open_id) that the scope is bound to. */
-  senderOpenId: z.string().min(1),
-  /** Epoch ms when the metadata was registered (clock seam for tests). */
-  receivedAt: z.number().int().nonnegative(),
-  /** Kind of message that carried the payload. */
-  kind: z.enum(PENDING_ATTACHMENT_KINDS),
-  /** Attachment payloads; empty for merged-forward containers (children are
-   *  listed through the container's own message id on fetch). */
-  resources: z.array(pendingAttachmentResourceSchema),
-  /** Remaining caption text after attachment placeholders, truncated. */
-  textExcerpt: z.string().min(1).optional(),
-  /** Set once the agent fetched the attachment; consumed rows leave the
-   *  manifest but stay queryable by message id until the TTL sweep. */
-  consumed: z.boolean().optional(),
-})
-
-export type PendingAttachmentRecord = z.infer<typeof pendingAttachmentRecordSchema>
-
 export interface FeishuDomainSpecShape {
-  name: 'channels_routes'
+  name: 'channels_routes_v2'
   version: 1
   global: {
     schema: z.ZodType<FeishuDomainGlobal>
@@ -401,8 +317,8 @@ export interface FeishuDomainSpecShape {
       valueSchema: typeof accessRequestRecordSchema
       __key?: string
     }
-    pending_attachments: {
-      valueSchema: typeof pendingAttachmentRecordSchema
+    access_wiki_users: {
+      valueSchema: typeof accessUserRecordSchema
       __key?: string
     }
   }
@@ -425,7 +341,9 @@ export type FeishuDomainGlobal = z.infer<typeof feishuDomainGlobalSchema>
  * runtime import of `@deepseek-ai/dsh-storage-domain`.
  */
 export const feishuDomain: FeishuDomainSpecShape = {
-  name: 'channels_routes',
+  // v2 keys every user by `user_id`. The open_id-keyed `channels_routes` unit
+  // is neither read nor migrated; it stays on disk untouched.
+  name: 'channels_routes_v2',
   version: 1,
   global: {
     schema: feishuDomainGlobalSchema,
@@ -439,7 +357,10 @@ export const feishuDomain: FeishuDomainSpecShape = {
     access_groups: { valueSchema: accessGroupRecordSchema },
     access_users: { valueSchema: accessUserRecordSchema },
     access_requests: { valueSchema: accessRequestRecordSchema },
-    pending_attachments: { valueSchema: pendingAttachmentRecordSchema },
+    // Wiki whitelist (`/auth wiki add`): same record as `access_users`, an
+    // independent grant. Added without a version bump like the other access
+    // tables: a missing table loads empty.
+    access_wiki_users: { valueSchema: accessUserRecordSchema },
   },
 }
 
@@ -490,7 +411,7 @@ export interface AccessGroupsTable {
   entries(): IterableIterator<[string, AccessGroupRecord]>
 }
 
-/** Normalized table handle for authorized users (key = `open_id`). */
+/** Normalized table handle for authorized users (key = `user_id`). */
 export interface AccessUsersTable {
   get(key: string): AccessUserRecord | undefined
   put(key: string, value: AccessUserRecord): Promise<unknown> | void
@@ -506,19 +427,6 @@ export interface AccessRequestsTable {
   entries(): IterableIterator<[string, AccessRequestRecord]>
 }
 
-/**
- * Normalized table handle for silently registered attachment metadata
- * (key = Feishu message id).
- */
-export interface PendingAttachmentsTable {
-  get(key: string): PendingAttachmentRecord | undefined
-  put(key: string, value: PendingAttachmentRecord): Promise<unknown> | void
-  /** Atomic read-modify-write on the host's write chain (`missing-key` when gone). */
-  update(key: string, fn: (current: PendingAttachmentRecord) => PendingAttachmentRecord): Promise<unknown>
-  delete(key: string): Promise<unknown> | void
-  entries(): IterableIterator<[string, PendingAttachmentRecord]>
-}
-
 /** Normalized domain handle. */
 export interface FeishuDomainHandle {
   routes: RoutesTable
@@ -528,12 +436,8 @@ export interface FeishuDomainHandle {
   accessGroups: AccessGroupsTable
   accessUsers: AccessUsersTable
   accessRequests: AccessRequestsTable
-  /**
-   * Pending attachment metadata. Optional on purpose: an embedded host whose
-   * storage domain refuses the added table leaves this undefined and the
-   * registry degrades to a process-memory TTL store (records lost on restart).
-   */
-  pendingAttachments?: PendingAttachmentsTable
+  /** Wiki whitelist (key = `user_id`); same records as {@link AccessUsersTable}. */
+  accessWikiUsers: AccessUsersTable
   getGlobal(): FeishuDomainGlobal
   setGlobal(value: FeishuDomainGlobal): Promise<unknown> | void
   close(): Promise<void>
@@ -558,9 +462,18 @@ export interface RawDomainHandle {
   close(): Promise<void>
 }
 
+/**
+ * Feishu tenant `user_id` (letters, digits, `_`, `-`). It doubles as a
+ * workspace path segment and as a DM target, where the SDK infers the
+ * receive id type from the prefix: `ou_`/`on_`/`oc_` would be sent as an
+ * open_id/union_id/chat_id, so those prefixes are rejected (a pasted open_id
+ * fails validation instead of matching nobody).
+ */
+export const FEISHU_USER_ID_PATTERN = /^(?!ou_|on_|oc_)[A-Za-z0-9_-]+$/u
+
 /** Build a chat-scoped fallback key for degraded (topic-less) routing. */
-export function chatRouteKey(chatType: 'p2p' | 'group', chatId: string, senderOpenId: string): string {
+export function chatRouteKey(chatType: 'p2p' | 'group', chatId: string, senderUserId: string): string {
   return chatType === 'p2p'
-    ? `chat:p2p:${chatId}:${senderOpenId}`
-    : `chat:group:${chatId}:${senderOpenId}`
+    ? `chat:p2p:${chatId}:${senderUserId}`
+    : `chat:group:${chatId}:${senderUserId}`
 }