@modesto_ma/dsh-channels 0.7.0 → 0.8.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modesto_ma/dsh-channels",
-  "version": "0.7.0",
+  "version": "0.8.0-beta.1",
   "description": "DeepSeek Harness (DSH) 飞书渠道插件：一个 dsh 实例对应一个飞书机器人，私聊/群聊/话题群 @ 触发会话，话题绑定 session，卡片 2.0 流式回复；Web 左侧栏提供「飞书渠道」状态与常用配置面板",
   "repository": {
     "type": "git",
@@ -19,6 +19,9 @@
       "types": "./src/client/index.ts",
       "default": "./lib/client.js"
     },
+    "./topics": {
+      "types": "./src/topics/contract.ts"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/access/controller.ts

@@ -185,12 +185,12 @@ export class AccessController {
   }
 
   /**
-   * Whether the analyze API may post into `chatId`: an authorized group, or
-   * any group in `open` access mode.
+   * Whether a `feishuTopics` launch may post into `chatId`: an authorized
+   * group, or any group in `open` access mode.
    * @param chatId - target group chat id.
    * @returns true when the chat is a permitted target.
    */
-  mayAnalyzeIn(chatId: string): boolean {
+  mayLaunchIn(chatId: string): boolean {
     if (this.config().accessMode === 'open') return true
     return this.deps.store.snapshot().groups.has(chatId)
   }

package/src/cards/index.ts

@@ -11,4 +11,4 @@ export * from './onboarding.ts'
 export * from './approval.ts'
 export * from './question.ts'
 export * from './picker.ts'
-export * from './analyze.ts'
+export * from './topic.ts'

package/src/cards/topic.ts

@@ -0,0 +1,104 @@
+/**
+ * Root card of a topic started through the `feishuTopics` service: the
+ * caller's title, an @-mention of the requester followed by the caller's lead
+ * sentence, an optional link table, and a status tag (进行中 → 已完成 /
+ * 已停止 / 失败 / 已中断) whose wording uses the caller's task name. The work
+ * itself streams in the topic below the card through the ordinary streaming
+ * card.
+ *
+ * @module dsh-channels/cards/topic
+ */
+
+import type { TopicRootCard } from '../topics/contract.ts'
+import { CARD_CONFIG, CARD_SCHEMA, markdown, note } from './primitives.ts'
+
+/**
+ * Root card status: `running` until the first turn settles (`done`,
+ * `stopped`, `error`), `failed` when the topic could not start, or
+ * `interrupted` when DSH restarted before the first turn settled.
+ */
+export type TopicStatus =
+  | { readonly kind: 'running' }
+  | { readonly kind: 'done' }
+  | { readonly kind: 'stopped' }
+  | { readonly kind: 'error' }
+  | { readonly kind: 'failed'; readonly reason: string }
+  | { readonly kind: 'interrupted' }
+
+/** Rows per table page (Feishu caps `page_size` at 10). */
+const TABLE_PAGE_SIZE = 10
+
+/** Escape markdown emphasis characters in caller-supplied text. */
+function plain(text: string): string {
+  return text.replace(/([*_~`[\]\\])/gu, '\\$1')
+}
+
+/** Percent-encode the characters that would end a markdown link target early. */
+function linkTarget(url: string): string {
+  return url.replace(/[()\s]/gu, char => `%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`)
+}
+
+/** Header tag text, tag color, and header template of each status. */
+function statusLook(status: TopicStatus, task: string): { tag: string; color: string; template: string } {
+  switch (status.kind) {
+    case 'running': return { tag: `${task}中`, color: 'blue', template: 'blue' }
+    case 'done': return { tag: '已完成', color: 'green', template: 'green' }
+    case 'stopped': return { tag: '已停止', color: 'neutral', template: 'grey' }
+    case 'error':
+    case 'failed': return { tag: '失败', color: 'red', template: 'red' }
+    case 'interrupted': return { tag: '已中断', color: 'orange', template: 'orange' }
+  }
+}
+
+/** Footer line of each status. */
+function statusNote(status: TopicStatus, task: string): string {
+  switch (status.kind) {
+    case 'running': return `${task}过程在本卡片下的话题内实时输出；群内已授权的成员可以在话题内直接回复追问。`
+    case 'done': return `${task}已完成，结果见话题；在话题内回复即可继续追问。`
+    case 'stopped': return `${task}已停止；在话题内回复即可继续。`
+    case 'error': return `${task}回合失败，原因见话题；在话题内回复即可重试或追问。`
+    case 'failed': return `${task}未能开始：${plain(status.reason)}`
+    case 'interrupted': return `DSH 重启导致${task}中断；在话题内回复即可继续。`
+  }
+}
+
+/**
+ * The topic root card.
+ * @param requesterUserId - `user_id` @-mentioned before the lead sentence.
+ * @param card - what the caller asked the card to show.
+ * @param status - the status the card shows.
+ * @returns card JSON.
+ */
+export function buildTopicRootCard(requesterUserId: string, card: TopicRootCard, status: TopicStatus): object {
+  const task = plain(card.taskName)
+  const look = statusLook(status, card.taskName)
+  const lead = card.lead.map(run => (run.bold === true ? `**${plain(run.text)}**` : plain(run.text))).join('')
+  const elements: object[] = [markdown(`<at id=${requesterUserId}></at> ${lead}`)]
+  if (card.links !== undefined && card.links.rows.length > 0) {
+    elements.push({
+      tag: 'table',
+      page_size: TABLE_PAGE_SIZE,
+      row_height: 'low',
+      header_style: { background_style: 'grey', bold: true, lines: 1 },
+      columns: [
+        { name: 'name', display_name: card.links.nameHeader, data_type: 'text', width: 'auto' },
+        { name: 'link', display_name: card.links.linkHeader, data_type: 'markdown', width: 'auto' },
+      ],
+      rows: card.links.rows.map(row => ({
+        name: row.name,
+        link: `[查看](${linkTarget(row.url)})`,
+      })),
+    })
+  }
+  elements.push(note(statusNote(status, task)))
+  return {
+    schema: CARD_SCHEMA,
+    config: CARD_CONFIG,
+    header: {
+      title: { tag: 'plain_text', content: card.title },
+      template: look.template,
+      text_tag_list: [{ tag: 'text_tag', text: { tag: 'plain_text', content: look.tag }, color: look.color }],
+    },
+    body: { elements },
+  }
+}

package/src/client/origin.tsx

@@ -171,7 +171,7 @@ function OriginDetails({ origin, onRefresh }: { origin: SessionOriginWire; onRef
     </span>
   )])
   const heading = originHeading(origin)
-  if (origin.shared) rows.push(['说明', '日志平台分析话题，群内成员都可以继续'])
+  if (origin.shared) rows.push(['说明', '群共享话题，群内成员都可以继续'])
   rows.push(['开始于', formatTime(origin.createdAt)])
   rows.push(origin.bound && origin.lastActivityAt !== undefined
     ? ['最近活跃', formatTime(origin.lastActivityAt)]

package/src/client/panel/advanced-tab.tsx

@@ -1,48 +1,24 @@
 /**
- * 「高级」tab：日志分析接口（开关 + 访问令牌凭据行）、SDK 日志级别
- * 与 Web 覆盖文件（「恢复 profile 配置」删除整个覆盖层，不走 draft）。
+ * 「高级」tab：SDK 日志级别与 Web 覆盖文件（「恢复 profile 配置」删除整个
+ * 覆盖层，不走 draft）。
  *
  * @module dsh-channels/client/panel/advanced-tab
  */
 
 import { fillCopy, PANEL_COPY, TAB_FIELD_GROUPS } from '../../settings/contract.ts'
-import { CredentialRow } from './credentials-card.tsx'
 import { FieldSections, Row, Section } from './shared.tsx'
-import type { AnalyzeTokenView, FormView } from './shared.tsx'
+import type { FormView } from './shared.tsx'
 
 export function AdvancedTab(props: {
   form: FormView
-  analyzeToken: AnalyzeTokenView
   onClear: () => void
 }): JSX.Element {
-  const { form, analyzeToken, onClear } = props
+  const { form, onClear } = props
   const { panel, busy, locked } = form
-  const tokenState = panel.config.credentials.analyzeToken
   const overridden = panel.config.overriddenKeys.length
   return (
     <div className="dsh-channels-cfg__tabBody">
-      <FieldSections
-        form={form}
-        groups={TAB_FIELD_GROUPS.advanced}
-        extra={{
-          analyze: (
-            <CredentialRow
-              label={PANEL_COPY.analyzeTokenLabel}
-              summary={PANEL_COPY.analyzeTokenSummary}
-              state={tokenState}
-              value={analyzeToken.value}
-              secret
-              placeholder={PANEL_COPY.analyzeTokenPlaceholder}
-              issue={analyzeToken.issues.find(item => item.key === 'analyzeToken')}
-              busy={analyzeToken.busy}
-              disabled={analyzeToken.busy !== null || analyzeToken.locked || !tokenState.writable}
-              onChange={analyzeToken.onChange}
-              onSave={analyzeToken.onSave}
-              onClear={analyzeToken.onClear}
-            />
-          ),
-        }}
-      />
+      <FieldSections form={form} groups={TAB_FIELD_GROUPS.advanced} />
       <Section title={PANEL_COPY.overlayTitle}>
         <Row
           label={PANEL_COPY.overlayPath}

package/src/client/panel/index.tsx

@@ -60,7 +60,6 @@ import {
   validateDraft,
 } from './shared.tsx'
 import type {
-  AnalyzeTokenView,
   BusyAction,
   CredentialsView,
   FormView,
@@ -95,7 +94,6 @@ function FeishuChannelsPanel(): JSX.Element | null {
   const [pollError, setPollError] = useState<string | null>(null)
   const [appIdInput, setAppIdInput] = useState('')
   const [appSecretInput, setAppSecretInput] = useState('')
-  const [analyzeTokenInput, setAnalyzeTokenInput] = useState('')
   const [catalog, setCatalog] = useState<CatalogWire | null>(null)
   const [catalogBusy, setCatalogBusy] = useState(false)
   const [accessNotice, setAccessNotice] = useState<string | null>(null)
@@ -122,7 +120,6 @@ function FeishuChannelsPanel(): JSX.Element | null {
       setDraft({})
       setAppIdInput('')
       setAppSecretInput('')
-      setAnalyzeTokenInput('')
     } catch (error) {
       setLoad({ phase: 'error', message: messageOf(error) })
     }
@@ -573,28 +570,6 @@ function FeishuChannelsPanel(): JSX.Element | null {
     }
   }, [appIdInput, appSecretInput])
 
-  /** Save the analyze API token; it applies to the next request, no reconnect. */
-  const onSaveAnalyzeToken = useCallback(async (): Promise<void> => {
-    if (analyzeTokenInput.trim() === '') return
-    setBusy('credentials')
-    setNotice(null)
-    try {
-      const result = await saveCredentials({ analyzeToken: analyzeTokenInput })
-      if (!result.ok) {
-        setNotice({ kind: 'error', text: result.error, issues: result.issues })
-        return
-      }
-      setLoad({ phase: 'ready', panel: result.panel })
-      setStatus(result.panel.status)
-      setAnalyzeTokenInput('')
-      setNotice({ kind: 'ok', text: PANEL_COPY.analyzeTokenSaved })
-    } catch (error) {
-      setNotice({ kind: 'error', text: messageOf(error) })
-    } finally {
-      setBusy(null)
-    }
-  }, [analyzeTokenInput])
-
   const onClearCredential = useCallback(async (field: CredentialField): Promise<void> => {
     const confirmed = typeof window.confirm === 'function'
       ? window.confirm(PANEL_COPY.credentialRemoveConfirm)
@@ -612,9 +587,7 @@ function FeishuChannelsPanel(): JSX.Element | null {
       setStatus(result.panel.status)
       setNotice({
         kind: 'ok',
-        text: field === 'analyzeToken'
-          ? PANEL_COPY.analyzeTokenRemoved
-          : result.reconnect === 'pending' ? PANEL_COPY.credentialRemovedPending : PANEL_COPY.credentialRemoved,
+        text: result.reconnect === 'pending' ? PANEL_COPY.credentialRemovedPending : PANEL_COPY.credentialRemoved,
       })
     } catch (error) {
       setNotice({ kind: 'error', text: messageOf(error) })
@@ -676,16 +649,6 @@ function FeishuChannelsPanel(): JSX.Element | null {
     onClear: (field: CredentialField) => { void onClearCredential(field) },
   }), [appIdInput, appSecretInput, busy, hostBusy, issues, onClearCredential, onSaveCredentials])
 
-  const analyzeToken = useMemo<AnalyzeTokenView>(() => ({
-    value: analyzeTokenInput,
-    issues,
-    busy,
-    locked: hostBusy,
-    onChange: setAnalyzeTokenInput,
-    onSave: () => { void onSaveAnalyzeToken() },
-    onClear: () => { void onClearCredential('analyzeToken') },
-  }), [analyzeTokenInput, busy, hostBusy, issues, onClearCredential, onSaveAnalyzeToken])
-
   if (load.phase === 'loading') {
     return (
       <div className="dsh-channels-cfg">
@@ -777,7 +740,7 @@ function FeishuChannelsPanel(): JSX.Element | null {
             )
           : null}
         {activeTab === 'advanced'
-          ? <AdvancedTab form={form} analyzeToken={analyzeToken} onClear={() => { void onClear() }} />
+          ? <AdvancedTab form={form} onClear={() => { void onClear() }} />
           : null}
       </div>
       <SaveBar

package/src/client/panel/shared.tsx

@@ -162,18 +162,6 @@ export interface CredentialsView {
   onClear: (field: CredentialField) => void
 }
 
-/** Analyze API token editor data owned by the page shell, rendered by the advanced tab. */
-export interface AnalyzeTokenView {
-  value: string
-  issues: FieldIssueWire[]
-  busy: BusyAction | null
-  /** Host-side lifecycle busy (connecting/restarting): block writes. */
-  locked: boolean
-  onChange: (value: string) => void
-  onSave: () => void
-  onClear: () => void
-}
-
 /** Everything a field-bearing tab needs from the page shell's single draft. */
 export interface FormView {
   panel: PanelWire

package/src/config.ts

@@ -80,8 +80,26 @@ export const DEFAULT_TOPIC_MESSAGES_TIMEOUT_MS = 20_000
  */
 export const DEFAULT_PROMPT_CONTEXT_TIMEOUT_MS = 3_000
 
-/** Conventional credential reference holding the log-platform analyze API bearer token. */
-export const DEFAULT_ANALYZE_TOKEN_REF = 'DSH_CHANNELS_ANALYZE_TOKEN'
+/**
+ * Keys of the log-platform analyze API, which moved to 观象
+ * (`@modesto_ma/dsh-guanxiang`). A value still set in `cordis.yml` or the Web
+ * overlay is ignored; the loader schema passes them through and
+ * {@link movedAnalyzeKeysOf} finds them so the deployment is told.
+ */
+export const MOVED_ANALYZE_KEYS = ['analyzeEnabled', 'analyzeToken'] as const
+
+/** Log line naming where the moved analyze API settings went. */
+export const MOVED_ANALYZE_NOTICE = 'dsh-channels: 日志分析接口已迁到观象（@modesto_ma/dsh-guanxiang），忽略 %s：请在观象面板「分析接口」中开启并保存令牌（GUANXIANG_ANALYZE_TOKEN）'
+
+/**
+ * The moved analyze API keys one raw config or overlay object still sets.
+ * @param raw - undecoded `config` or overlay JSON.
+ * @returns the keys present, in {@link MOVED_ANALYZE_KEYS} order.
+ */
+export function movedAnalyzeKeysOf(raw: unknown): string[] {
+  if (typeof raw !== 'object' || raw === null) return []
+  return MOVED_ANALYZE_KEYS.filter(key => Object.hasOwn(raw, key))
+}
 
 /** A credential reference: `FEISHU_APP_ID`-style name resolved through ctx.credentials. */
 const credentialRefSchema = z.string().regex(
@@ -421,18 +439,6 @@ export const configSchema = z.object({
    * its own deadline and is left to the host signal instead.
    */
   questionTimeoutMs: z.number().int().min(10_000).max(3_600_000).default(DEFAULT_QUESTION_TIMEOUT_MS),
-  /**
-   * Switch for the log-platform analyze API (`POST /open-api/logalyze`
-   * on the DSH Web server). Off (default) answers 404; read per request, so
-   * toggling it needs no reconnect. Needs a host with a Web server.
-   */
-  analyzeEnabled: z.boolean().default(false),
-  /**
-   * Credential reference holding the analyze API bearer token (defaults to
-   * `DSH_CHANNELS_ANALYZE_TOKEN`). Resolved per request, so rotating the value
-   * applies to the next request; an unresolvable token refuses every request.
-   */
-  analyzeToken: credentialRefSchema.default(DEFAULT_ANALYZE_TOKEN_REF),
 })
 
 export type FeishuConfig = z.infer<typeof configSchema>
@@ -442,9 +448,13 @@ export type FeishuConfig = z.infer<typeof configSchema>
  * `config` object; the loader validates that row with `undefined` before the
  * user's patch layer supplies values. Accept that absence and fill the same
  * defaults as {@link resolveConfig}, so enabling the plugin from the Web UI
- * cannot fail with "expected object, received undefined".
+ * cannot fail with "expected object, received undefined". The moved analyze
+ * keys pass through unchanged so `apply()` can warn about them.
  */
-export const pluginConfigSchema = configSchema.prefault({})
+export const pluginConfigSchema = configSchema.extend({
+  analyzeEnabled: z.unknown().optional(),
+  analyzeToken: z.unknown().optional(),
+}).prefault({})
 
 /**
  * Validate the raw loader config. Values stay credential *references*; the

package/src/domain.ts

@@ -9,6 +9,7 @@
  */
 
 import { z } from 'zod'
+import type { TopicRootCard } from './topics/contract.ts'
 
 /**
  * Route key kinds. `thread` = real Feishu topic; `chat` = degraded chat-scoped
@@ -62,7 +63,7 @@ export const routeRecordSchema = z.object({
   /** Sessions this topic has pointed at, oldest first. Optional for v1 compatibility. */
   sessionHistory: z.array(sessionHistoryEntrySchema).optional(),
   /**
-   * Group-shared route (log-platform analysis topics): every member admitted
+   * Group-shared route (topics started through `feishuTopics`): every member admitted
    * in `chatId` may continue the Session and decide its cards, not only
    * `senderUserId` (who then names the requester). Absent = owner-only.
    */
@@ -287,44 +288,100 @@ export const processedRecordSchema = z.object({
 
 export type ProcessedRecord = z.infer<typeof processedRecordSchema>
 
+/** {@link TopicRootCard} as stored in a launch record. */
+export const topicRootCardSchema = z.object({
+  title: z.string(),
+  taskName: z.string(),
+  lead: z.array(z.object({ text: z.string(), bold: z.boolean().optional() })),
+  links: z.object({
+    nameHeader: z.string(),
+    linkHeader: z.string(),
+    rows: z.array(z.object({ name: z.string(), url: z.string() })),
+  }).optional(),
+})
+
 /**
- * One accepted analyze API request, keyed by its `Idempotency-Key`. Kept
- * forever: a retried key returns the stored response instead of posting a
- * second analysis, and a reused key with a different body is refused.
+ * Root card content written by plugin versions before the `feishuTopics`
+ * service (the built-in log-platform analyze API). Read only; converted by
+ * {@link rootCardOf}.
  */
-export const analyzeRequestRecordSchema = z.object({
-  /** The request's `Idempotency-Key` (also the table key). */
+const legacyAnalyzeSubjectSchema = z.object({
+  requesterUserId: z.string(),
+  triggeredAt: z.string(),
+  app: z.string(),
+  errorCode: z.string(),
+  logDetails: z.array(z.object({ name: z.string(), url: z.string() })),
+})
+
+/**
+ * One accepted `feishuTopics` launch, keyed by its idempotency key. Kept
+ * forever: a retried key answers the stored root card instead of posting a
+ * second topic, and a reused key with another fingerprint is refused. The
+ * records live in the `analyze_requests` table, named after the analyze API
+ * that wrote the first of them; those older records carry `subject` instead
+ * of `requesterUserId` + `card`, and their keys are the analyze API's
+ * `Idempotency-Key`s.
+ */
+export const topicLaunchRecordSchema = z.object({
+  /** The launch's idempotency key (also the table key). */
   key: z.string().min(1),
-  /** SHA-256 (hex) of the canonical request body. */
+  /** The launch's fingerprint (older records: SHA-256 of the analyze request). */
   bodyHash: z.string().min(1),
   /** Target group chat. */
   chatId: z.string().min(1),
-  /** Root card message id (the analysis topic's root). */
+  /** Root card message id (the topic's root). */
   messageId: z.string().min(1),
-  /** Epoch ms when the request was accepted. */
+  /** Epoch ms when the launch was accepted. */
   acceptedAt: z.number().int().nonnegative(),
-  /** What the root card shows, kept so the card can be redrawn after a restart. */
-  subject: z.object({
-    requesterUserId: z.string(),
-    triggeredAt: z.string(),
-    app: z.string(),
-    errorCode: z.string(),
-    logDetails: z.array(z.object({ name: z.string(), url: z.string() })),
-  }),
+  /** Requester @-mentioned on the root card; absent on older records. */
+  requesterUserId: z.string().optional(),
+  /** What the root card shows, kept so the card can be redrawn after a restart; absent on older records. */
+  card: topicRootCardSchema.optional(),
+  /** Root card content of older records. */
+  subject: legacyAnalyzeSubjectSchema.optional(),
   /**
    * Root card status. `running` until the first turn settles; a record still
-   * `running` when the channel starts belongs to an analysis the previous
+   * `running` when the channel starts belongs to a topic the previous
    * instance never finished, and becomes `interrupted`.
    */
   status: z.enum(['running', 'done', 'stopped', 'error', 'failed', 'interrupted']),
 })
 
-export type AnalyzeRequestRecord = z.infer<typeof analyzeRequestRecordSchema>
+export type TopicLaunchRecord = z.infer<typeof topicLaunchRecordSchema>
+
+/**
+ * The requester and root card content of one launch record, converting the
+ * analyze API's older records to the card that API drew.
+ * @param record - stored launch record.
+ * @returns what to redraw, or undefined for a record carrying neither form.
+ */
+export function rootCardOf(record: TopicLaunchRecord): { requesterUserId: string; card: TopicRootCard } | undefined {
+  if (record.card !== undefined && record.requesterUserId !== undefined) {
+    return { requesterUserId: record.requesterUserId, card: record.card }
+  }
+  const subject = record.subject
+  if (subject === undefined) return undefined
+  return {
+    requesterUserId: subject.requesterUserId,
+    card: {
+      title: '日志分析',
+      taskName: '分析',
+      lead: [
+        { text: `于 ${subject.triggeredAt} 发起了对 ` },
+        { text: subject.app, bold: true },
+        { text: ' 应用 ' },
+        { text: subject.errorCode, bold: true },
+        { text: ' 错误码不良日志的分析。' },
+      ],
+      links: { nameHeader: '日志', linkHeader: '详情页', rows: subject.logDetails },
+    },
+  }
+}
 
 /**
  * Where one Feishu-routed Session came from, keyed by its DSH session id.
  * Written the first time a route record names the Session (new topic,
- * `/renew`, analyze API) and kept after the route retires, so the Web
+ * `/renew`, `feishuTopics` launch) and kept after the route retires, so the Web
  * client can still show the origin of an old Session. Names are resolved
  * live when read, never stored.
  */
@@ -339,11 +396,11 @@ export const sessionOriginRecordSchema = z.object({
   chatId: z.string().min(1),
   /** `p2p` or `group`. */
   chatType: z.enum(['p2p', 'group']),
-  /** `user_id` of the user who started the Session (the requester for analyze topics). */
+  /** `user_id` of the user who started the Session (the requester for launched topics). */
   senderUserId: z.string().min(1),
   /** Epoch ms when the Session was bound to the route. */
   createdAt: z.number().int().nonnegative(),
-  /** Group-shared route (log-platform analysis topic). */
+  /** Group-shared route (topic started through `feishuTopics`). */
   shared: z.literal(true).optional(),
 })
 
@@ -390,7 +447,7 @@ export interface FeishuDomainSpecShape {
       __key?: string
     }
     analyze_requests: {
-      valueSchema: typeof analyzeRequestRecordSchema
+      valueSchema: typeof topicLaunchRecordSchema
       __key?: string
     }
     session_origins: {
@@ -437,8 +494,8 @@ export const feishuDomain: FeishuDomainSpecShape = {
     // independent grant. Added without a version bump like the other access
     // tables: a missing table loads empty.
     access_wiki_users: { valueSchema: accessUserRecordSchema },
-    // Analyze API idempotency records; a missing table loads empty.
-    analyze_requests: { valueSchema: analyzeRequestRecordSchema },
+    // `feishuTopics` launch records (historical name); a missing table loads empty.
+    analyze_requests: { valueSchema: topicLaunchRecordSchema },
     // Session id → Feishu origin; a missing table loads empty.
     session_origins: { valueSchema: sessionOriginRecordSchema },
   },
@@ -507,11 +564,11 @@ export interface AccessRequestsTable {
   entries(): IterableIterator<[string, AccessRequestRecord]>
 }
 
-/** Normalized table handle for analyze API requests (key = `Idempotency-Key`). */
-export interface AnalyzeRequestsTable {
-  get(key: string): AnalyzeRequestRecord | undefined
-  put(key: string, value: AnalyzeRequestRecord): Promise<unknown> | void
-  entries(): IterableIterator<[string, AnalyzeRequestRecord]>
+/** Normalized table handle for `feishuTopics` launches (key = idempotency key). */
+export interface TopicLaunchesTable {
+  get(key: string): TopicLaunchRecord | undefined
+  put(key: string, value: TopicLaunchRecord): Promise<unknown> | void
+  entries(): IterableIterator<[string, TopicLaunchRecord]>
 }
 
 /** Normalized table handle for the session-origin table (key = DSH session id). */
@@ -531,8 +588,8 @@ export interface FeishuDomainHandle {
   accessRequests: AccessRequestsTable
   /** Wiki whitelist (key = `user_id`); same records as {@link AccessUsersTable}. */
   accessWikiUsers: AccessUsersTable
-  /** Analyze API idempotency records. */
-  analyzeRequests: AnalyzeRequestsTable
+  /** `feishuTopics` launch records. */
+  topicLaunches: TopicLaunchesTable
   /** Feishu origin of every Session a route ever named. */
   sessionOrigins: SessionOriginsTable
   getGlobal(): FeishuDomainGlobal

package/src/host/core.ts

@@ -317,10 +317,39 @@ export interface AgentPresetSelectedEvent extends SessionEventEnvelope {
   data: { agentPreset: string }
 }
 
+/**
+ * Durable record of one model-request retry scheduled by `dsh-llm-retry`
+ * (DSH `packages/llm/llm-retry/src/types.ts`), appended before the backoff
+ * wait. The retry re-runs the failed step inside the SAME open turn: only
+ * `turn/end` ends the turn.
+ */
+export interface LlmRetryEvent extends SessionEventEnvelope {
+  type: 'llm/retry'
+  data: {
+    turn: number
+    step: number
+    provider: string
+    mode: 'normal' | 'always'
+    /** 1-based retry number. */
+    retry: number
+    /** Retry budget in `normal` mode; absent in `always` mode (unbounded). */
+    maxRetries?: number
+    delayMs: number
+    failure: { message: string; code: string; [key: string]: unknown }
+    [key: string]: unknown
+  }
+}
+
+/** Appended when a retry's backoff wait ends, right before the retried request starts. */
+export interface LlmRetryStartedEvent extends SessionEventEnvelope {
+  type: 'llm/retry-started'
+  data: { turn: number; step: number; retry: number; [key: string]: unknown }
+}
+
 export interface OtherSessionEvent extends SessionEventEnvelope {
   /** Unknown/extension event types are ignored by the folds. */
   type: Exclude<string, 'assistant/message' | 'step/start' | 'turn/end' | 'request/header'
-    | 'tool/call' | 'tool/result' | 'subagent/descriptor'
+    | 'tool/call' | 'tool/result' | 'subagent/descriptor' | 'llm/retry' | 'llm/retry-started'
     | 'command/run' | 'command/done'
     | 'tool-workflow/run-start' | 'tool-workflow/agent-start' | 'tool-workflow/agent-end' | 'tool-workflow/run-end'>
   data: unknown
@@ -342,4 +371,6 @@ export type SessionEvent =
   | ToolWorkflowAgentStartEvent
   | ToolWorkflowAgentEndEvent
   | ToolWorkflowRunEndEvent
+  | LlmRetryEvent
+  | LlmRetryStartedEvent
 

package/src/host/services.ts

@@ -288,6 +288,11 @@ export interface HostContext {
   logger?: HostLogger
   /** Safe service lookup (returns undefined for absent services). */
   get?(name: string): unknown
+  /**
+   * Provide a service owned by this plugin's fiber; it is withdrawn when the
+   * plugin unloads. Optional so test contexts may omit it.
+   */
+  provide?(name: string, value: unknown): () => void
   /** Host events this plugin subscribes to (overloads per event). */
   on(name: 'session/event', listener: (session: Session, event: SessionEvent) => void): () => boolean
   /** Live (transient) model stream for every agent; replaces the removed `assistant/chunk` events. */