@miphamai/cli 0.51.0 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -45,7 +45,6 @@
     "commander": "^13.1.0",
     "ink": "^5.2.1",
     "ink-text-input": "^6.0.0",
-    "js-tiktoken": "^1.0.21",
     "react": "^18.3.1",
     "react-devtools-core": "^4.28.5",
     "yaml": "^2.9.0"

package/skills/mipham/save-to-wiki.mipham-skill.md

@@ -0,0 +1,92 @@
+---
+name: save-to-wiki
+description: Save the current conversation, an insight, or a decision into the Obsidian wiki vault (~/MiphamAI) as a structured note. Analyzes the chat, picks a note type (synthesis/concept/source/decision/session), writes it via the Obsidian MCP, and leaves a memory pointer back. Use when the user types /save, says "save this to the wiki", "file this", "keep this insight", or wants a decision/concept archived.
+version: 1.0.0
+---
+
+# Save to Wiki
+
+Good answers and insights shouldn't disappear into chat history. This skill files the most valuable content from the current conversation into the user's Obsidian wiki as a permanent, searchable note.
+
+The wiki compounds. Save often.
+
+## Transport
+
+Writes go through the Obsidian MCP server (`obsidian` in `~/.mipham/mcp.json`), exposed as tools prefixed `mcp__obsidian__`:
+
+- `mcp__obsidian__create_note` — create a new note (target path + markdown body)
+- `mcp__obsidian__append_note` — append to an existing note
+- `mcp__obsidian__get_file` / `mcp__obsidian__list_files` — check whether a note already exists
+- `mcp__obsidian__set_property` — update frontmatter properties
+
+If a tool name is unfamiliar, run `/mcp` to list the connected Obsidian tools and use the exact names. Avoid `get_vault_info` — it has a known upstream bug (`Command "vault" not found`) and is not needed for writing.
+
+## Note Type Decision
+
+Pick the best type from the conversation content. If the user specifies a type, use it.
+
+| Type      | Folder (`wiki/`) | Use when                                                 |
+| --------- | ---------------- | -------------------------------------------------------- |
+| synthesis | `questions/`     | Multi-step analysis, comparison, or answer to a question |
+| concept   | `concepts/`      | Explaining or defining an idea, pattern, or framework    |
+| source    | `sources/`       | Summary of external material discussed in the session    |
+| decision  | `meta/`          | Architectural, project, or strategic decision made       |
+| session   | `sessions/`      | Full session summary — captures everything discussed     |
+
+When in doubt, use `synthesis`.
+
+## Frontmatter
+
+All note types share this base frontmatter (aligns with the vault's `_templates/`):
+
+```yaml
+---
+type: <synthesis|concept|source|decision|session>
+title: 'Note Title'
+created: YYYY-MM-DD
+updated: YYYY-MM-DD
+tags:
+  - <relevant-tag>
+status: developing
+related:
+  - '[[Any Wiki Page Mentioned]]'
+sources: []
+saved_from: Mipham Code
+mipham_memory: <memory-slug>
+---
+```
+
+- `synthesis` adds: `question: "<original query>"`, `answer_quality: solid`
+- `decision` adds: `decision_date: YYYY-MM-DD`
+- `saved_from` and `mipham_memory` implement the light two-way bridge (see below).
+
+## Workflow
+
+1. **Scan** the conversation and identify the single most valuable content to preserve — an insight, a decision with rationale, or a synthesis. If the conversation is trivial (mechanical Q&A, setup steps already documented, temp debugging), say so and skip.
+2. **Determine** the note type using the table. Respect an explicit type/title from the user.
+3. **Name** the note — short and descriptive; ask the user if not already named.
+4. **Check existence** — use `list_files`/`get_file` to see whether `wiki/<folder>/<title>.md` already exists. If it does, offer to update (`append_note` or rewrite) instead of duplicating.
+5. **Write** the note via `create_note` (path `wiki/<folder>/<title>.md`) with full frontmatter and a declarative, present-tense body.
+6. **Leave a memory pointer** — write a `reference` memory via the Memory tool (`action=write`, `name=wiki-<title-slug>`) whose body records the wiki note path and a one-line summary. This lets `/memory` and recall surface the wiki note.
+7. **Update** `wiki/index.md` (add the note to the relevant section) and `wiki/log.md` (prepend `## [YYYY-MM-DD] save | Note Title`). Refresh `wiki/hot.md` if it tracks recent additions.
+
+## Light Two-Way Bridge
+
+- **memory → wiki**: the pointer memory (step 6) stores the wiki path, so memory recall can link back to the note.
+- **wiki → memory**: the note's frontmatter carries `saved_from: Mipham Code` and `mipham_memory: <slug>` — plain strings, not wikilinks, so they don't create broken links in Obsidian.
+
+This is a one-way pointer plus a provenance back-reference, not a sync layer. Do not attempt bidirectional synchronization.
+
+## Writing Style
+
+- Declarative, present tense. Write the knowledge, not the conversation.
+- Not: "The user asked about X and Claude explained..."
+- Yes: "X works by doing Y. The key insight is Z."
+- Link mentioned concepts/entities/wiki pages with `[[wikilinks]]`.
+- Cite sources where applicable: `(Source: [[Page]])`.
+
+## What to Save vs. Skip
+
+**Save**: non-obvious insights, decisions with rationale, analyses that took real effort, comparisons likely to be referenced again, research findings.
+
+**Skip**: mechanical Q&A, setup steps already documented, temporary debugging with no lasting insight, anything already in the wiki (update instead of duplicating).

package/src/commands/keys.ts

@@ -1,5 +1,6 @@
 import type { CommandHandler } from '../ui/commands'
 import { KeyManager } from '../config/keys-manager'
+import { getProviderApiKey } from '../config/loader'
 
 export const keysCmd: CommandHandler = async (_ctx, args) => {
   const manager = new KeyManager()
@@ -58,6 +59,31 @@ export const keysCmd: CommandHandler = async (_ctx, args) => {
     return { content: lines.join('\n') }
   }
 
+  // /keys view <provider> — show the plaintext API key (decrypting if stored encrypted)
+  if (sub === 'view' || sub === 'show') {
+    const provider = args[1]
+    if (!provider) {
+      return { content: 'Usage: /keys view <provider>\n\nExample: /keys view deepseek' }
+    }
+    const key = getProviderApiKey(provider)
+    if (key === null) {
+      return {
+        content: `No API key found for provider "${provider}".\n\nIf it was stored encrypted, it may be unreadable (missing/corrupt credential key).`,
+      }
+    }
+    return {
+      content: [
+        '── Key View ──',
+        '',
+        `Provider: ${provider}`,
+        `API Key:  ${key}`,
+        '',
+        '⚠️  This is your plaintext API key. Do not share it or paste it anywhere.',
+        '    Rotate it at any time with /keys rotate <provider>.',
+      ].join('\n'),
+    }
+  }
+
   // /keys (list)
   const keys = manager.list()
 

package/src/config/credential-crypto.ts

@@ -0,0 +1,114 @@
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  chmodSync,
+  copyFileSync,
+} from 'node:fs'
+import { dirname, join } from 'node:path'
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
+
+/**
+ * Shared AES-256-GCM primitives for encrypting credentials at rest.
+ *
+ * Extracted from the MCP token store so config.yml API keys get the exact
+ * same at-rest protection (parent/subsidiary CLAUDE.md mandate "存储层
+ * AES-256-GCM"). The wire format `iv || authTag || ciphertext` (base64) is
+ * preserved verbatim from the original token-store implementation so existing
+ * `~/.mipham/mcp-tokens/*.enc` files remain decryptable.
+ */
+
+const ALGORITHM = 'aes-256-gcm'
+const IV_LENGTH = 16
+const AUTH_TAG_LENGTH = 16
+const KEY_LENGTH = 32
+
+/** Prefix marking an encrypted API key value in config.yml. */
+export const ENC_PREFIX = 'enc:v1:'
+
+/** Shared master-credential key file (used by both MCP tokens and config.yml). */
+const CREDENTIAL_KEY_FILENAME = '.cred-key'
+/** Pre-shared-key filename; migrated to {@link CREDENTIAL_KEY_FILENAME} on first use. */
+const LEGACY_KEY_FILENAME = '.mcp-key'
+
+/**
+ * Load the shared credential key from `keyDir`, migrating the legacy
+ * MCP-only `.mcp-key` to the shared `.cred-key` so existing encrypted MCP
+ * tokens stay decryptable. Falls back to creating a fresh key when neither
+ * exists.
+ */
+export function getCredentialKey(keyDir: string): Buffer {
+  const keyPath = join(keyDir, CREDENTIAL_KEY_FILENAME)
+  if (!existsSync(keyPath)) {
+    const legacyPath = join(keyDir, LEGACY_KEY_FILENAME)
+    if (existsSync(legacyPath)) {
+      copyFileSync(legacyPath, keyPath)
+      chmodSync(keyPath, 0o400)
+    }
+  }
+  return getOrCreateKey(keyPath)
+}
+
+/**
+ * Load the 32-byte encryption key from `keyPath`, creating a fresh random key
+ * (with owner-only read permissions) on first use.
+ */
+export function getOrCreateKey(keyPath: string): Buffer {
+  if (existsSync(keyPath)) {
+    return readFileSync(keyPath)
+  }
+  const key = randomBytes(KEY_LENGTH)
+  mkdirSync(dirname(keyPath), { recursive: true })
+  writeFileSync(keyPath, key)
+  chmodSync(keyPath, 0o400)
+  return key
+}
+
+/** Encrypt plaintext with AES-256-GCM. Returns `base64(iv || authTag || ciphertext)`. */
+export function encrypt(plaintext: string, key: Buffer): string {
+  const iv = randomBytes(IV_LENGTH)
+  const cipher = createCipheriv(ALGORITHM, key, iv)
+  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf-8'), cipher.final()])
+  const authTag = cipher.getAuthTag()
+  return Buffer.concat([iv, authTag, encrypted]).toString('base64')
+}
+
+/** Decrypt a value produced by {@link encrypt}. Throws on wrong key / corrupt data. */
+export function decrypt(ciphertext: string, key: Buffer): string {
+  const buf = Buffer.from(ciphertext, 'base64')
+  const iv = buf.subarray(0, IV_LENGTH)
+  const authTag = buf.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH)
+  const encrypted = buf.subarray(IV_LENGTH + AUTH_TAG_LENGTH)
+  const decipher = createDecipheriv(ALGORITHM, key, iv)
+  decipher.setAuthTag(authTag)
+  return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf-8')
+}
+
+/**
+ * True when `value` is an environment-variable template rather than a literal
+ * secret — both `${VAR}` and `$VAR` forms (the provider resolvers accept both).
+ */
+export function isEnvTemplate(value: string): boolean {
+  return /^\$\{.*\}$/.test(value) || /^\$[A-Z_][A-Z0-9_]*$/.test(value)
+}
+
+/**
+ * Encrypt an API key for storage. Environment-variable templates and empty
+ * values are not secrets, so they pass through unchanged (keeping config.yml
+ * readable for env-based setups). Literal secrets get the `enc:v1:` prefix.
+ */
+export function encryptApiKey(apiKey: string, key: Buffer): string {
+  if (!apiKey || isEnvTemplate(apiKey)) return apiKey
+  return ENC_PREFIX + encrypt(apiKey, key)
+}
+
+/**
+ * Decrypt a stored API key. Plaintext (legacy or template) values pass through
+ * unchanged; `enc:v1:` values are decrypted. Throws on a missing/corrupt key so
+ * the caller can surface a clear error instead of sending a garbage key.
+ */
+export function decryptApiKey(stored: string, key: Buffer): string {
+  if (!stored.startsWith(ENC_PREFIX)) return stored
+  return decrypt(stored.slice(ENC_PREFIX.length), key)
+}

package/src/config/defaults.ts

@@ -28,7 +28,7 @@ export const DEFAULT_CONFIG: MiphamConfig = {
   },
   features: {
     mcp: { oauthEnabled: true },
-    context: { useRealTokenizer: true, adaptiveThresholds: true },
+    context: { adaptiveThresholds: true },
   },
   crsi: {
     ruleInjection: true,

package/src/config/loader.ts

@@ -27,6 +27,7 @@ import {
   DEFAULT_BACKGROUND_AGENT_CONFIG,
   DEFAULT_CROSS_SESSION_CONFIG,
 } from './defaults'
+import { getCredentialKey, encryptApiKey, decryptApiKey, ENC_PREFIX } from './credential-crypto'
 
 const MIPHAM_HOME = join(homedir(), '.mipham')
 const BACKUP_PREFIX = 'config.backup-'
@@ -294,6 +295,9 @@ export function loadConfig(cwd: string = process.cwd()): MiphamConfig {
     backupConfig(userConfigPath)
   }
 
+  // ── Decrypt API keys at rest (enc:v1:) back to plaintext ──
+  decryptProviderApiKeys(config.providers)
+
   return config
 }
 
@@ -438,6 +442,58 @@ export function loadCrossSessionConfig(cwd: string = process.cwd()): CrossSessio
   return merged
 }
 
+/**
+ * Decrypt any encrypted (`enc:v1:`) provider API keys in place, after config
+ * merge. Plaintext (legacy / env-template) values pass through untouched. On
+ * decrypt failure (missing/corrupt credential key) the key is cleared and a
+ * warning is written, so the provider surfaces "apiKey not set" rather than
+ * sending a garbage value.
+ */
+function decryptProviderApiKeys(providers: ProviderConfig[] | undefined): void {
+  if (!providers) return
+  const needsKey = providers.some((p) => p.apiKey.startsWith(ENC_PREFIX))
+  if (!needsKey) return
+  const key = getCredentialKey(MIPHAM_HOME)
+  for (const p of providers) {
+    if (!p.apiKey.startsWith(ENC_PREFIX)) continue
+    try {
+      p.apiKey = decryptApiKey(p.apiKey, key)
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err)
+      process.stderr.write(
+        `⚠ Mipham Code: failed to decrypt API key for "${p.id}" (credential key missing/corrupt?): ${msg}\n`,
+      )
+      p.apiKey = ''
+    }
+  }
+}
+
+/**
+ * Read a single provider's API key from config.yml, decrypting it if stored
+ * encrypted. Returns null when the provider has no key or the key can't be
+ * decrypted. Used by `/keys view` to show the plaintext key on request.
+ */
+export function getProviderApiKey(providerId: string, cwd: string = process.cwd()): string | null {
+  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
+  const projectConfigPath = join(cwd, '.mipham', 'config.yml')
+  const configPath = existsSync(userConfigPath) ? userConfigPath : projectConfigPath
+
+  try {
+    if (!existsSync(configPath)) return null
+    const raw = readFileSync(configPath, 'utf-8')
+    const doc = (parseYaml(raw) as Record<string, unknown>) || {}
+    const providers = (doc.providers as Array<Record<string, unknown>>) || []
+    const p = providers.find((x) => x.id === providerId)
+    if (!p || typeof p.apiKey !== 'string') return null
+    if (!p.apiKey.startsWith(ENC_PREFIX)) return p.apiKey
+    return decryptApiKey(p.apiKey, getCredentialKey(MIPHAM_HOME))
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err)
+    process.stderr.write(`⚠ Mipham Code: failed to read API key for "${providerId}": ${msg}\n`)
+    return null
+  }
+}
+
 /**
  * Persist an API key for a single provider to the user-level config.yml.
  * Reads the existing YAML, updates/replaces the provider's apiKey field,
@@ -445,16 +501,10 @@ export function loadCrossSessionConfig(cwd: string = process.cwd()): CrossSessio
  *
  * Returns true on success, false on failure.
  */
-export function saveProviderApiKey(
-  providerId: string,
-  apiKey: string,
-  cwd: string = process.cwd(),
-): boolean {
-  const userConfigPath = join(MIPHAM_HOME, 'config.yml')
-  const projectConfigPath = join(cwd, '.mipham', 'config.yml')
-
-  // Prefer user-level config; fall back to project-level if no user config exists.
-  const configPath = existsSync(userConfigPath) ? userConfigPath : projectConfigPath
+export function saveProviderApiKey(providerId: string, apiKey: string): boolean {
+  // API keys are user-level secrets — always persist to the user config, never
+  // the project config (which lives in the repo and could be committed).
+  const configPath = join(MIPHAM_HOME, 'config.yml')
 
   try {
     mkdirSync(MIPHAM_HOME, { recursive: true, mode: 0o700 })
@@ -464,19 +514,20 @@ export function saveProviderApiKey(
     if (existsSync(configPath)) {
       const raw = readFileSync(configPath, 'utf-8')
       doc = (parseYaml(raw) as Record<string, unknown>) || {}
-    } else if (configPath === projectConfigPath) {
-      mkdirSync(join(cwd, '.mipham'), { recursive: true })
     }
 
     // Find and update the provider in the providers array
     const providers = (doc.providers as Array<Record<string, unknown>>) || []
     const idx = providers.findIndex((p) => p.id === providerId)
 
+    // Encrypt literal keys at rest (env-variable templates pass through).
+    const storedKey = encryptApiKey(apiKey, getCredentialKey(MIPHAM_HOME))
+
     if (idx >= 0) {
-      providers[idx] = { ...providers[idx], apiKey }
+      providers[idx] = { ...providers[idx], apiKey: storedKey }
     } else {
       // Provider not in config — append it
-      providers.push({ id: providerId, apiKey })
+      providers.push({ id: providerId, apiKey: storedKey })
     }
 
     doc.providers = providers

package/src/core/instructions.ts

@@ -20,9 +20,37 @@ function parseFrontmatter(raw: string): FrontmatterResult {
   }
 }
 
+/** Strip the named sections (by heading title) from a markdown document. */
+export function stripSections(content: string, excluded: string[]): string {
+  if (excluded.length === 0) return content
+  const lines = content.split('\n')
+  const out: string[] = []
+  let skipLevel = 0
+  for (const line of lines) {
+    const m = line.match(/^(#{1,3})\s+(.+?)\s*$/)
+    if (m) {
+      const level = m[1]!.length
+      const title = m[2]!.trim()
+      if (excluded.includes(title)) {
+        skipLevel = level
+      } else if (skipLevel > 0 && level <= skipLevel) {
+        skipLevel = 0
+      }
+    }
+    if (skipLevel === 0) out.push(line)
+  }
+  return out.join('\n')
+}
+
+/** Normalize a `prompt-exclude` frontmatter value (YAML list or single string). */
+export function parsePromptExclude(value: unknown): string[] {
+  if (Array.isArray(value)) return value.map((v) => String(v))
+  if (typeof value === 'string') return [value]
+  return []
+}
+
 export class InstructionsLoader {
   private instructions: InstructionFile[] = []
-  private skillsReminder = ''
 
   loadAll(cwd: string): void {
     this.instructions = []
@@ -59,7 +87,13 @@ export class InstructionsLoader {
         directory: 'Directory Rules',
         user: 'User Preferences',
       }
-      parts.push(`<!-- ${levelLabel[inst.level] || inst.level} (${inst.path}) -->\n${inst.content}`)
+      // Strip doc-only sections declared via `prompt-exclude` frontmatter
+      // (changelog/roadmap/catalog are human-facing, not machine rules).
+      const content = stripSections(
+        inst.content,
+        parsePromptExclude(inst.frontmatter['prompt-exclude']),
+      )
+      parts.push(`<!-- ${levelLabel[inst.level] || inst.level} (${inst.path}) -->\n${content}`)
     }
 
     // P2-2: Inject current permission mode so the model knows its constraints
@@ -67,11 +101,6 @@ export class InstructionsLoader {
       parts.push(this.buildPermissionContext(permissionMode))
     }
 
-    // Append skills reminder after all instructions
-    if (this.skillsReminder) {
-      parts.push(this.skillsReminder)
-    }
-
     // Inject critical thinking self-check layer (for analysis/comparison tasks)
     parts.push(`## Critical Thinking Self-Check
 
@@ -177,11 +206,6 @@ Never omit it or present the work as purely human-authored.`)
     return parts.join('\n\n---\n\n')
   }
 
-  /** Set the skills system-reminder block to inject into the system prompt. */
-  setSkillsReminder(reminder: string): void {
-    this.skillsReminder = reminder
-  }
-
   /**
    * P2-2: Build a permission-mode context block for the system prompt.
    * Tells the model its current permission level and what to expect.

package/src/daemon/channel-message.ts

@@ -0,0 +1,59 @@
+import type { SessionManager } from './session-manager'
+import type { SessionWorker } from './session-worker'
+import type { RateLimiter } from './rate-limiter'
+
+export interface ChannelMessageOptions {
+  channel: string // 'feishu' | 'telegram' | 'wecom'
+  externalId: string // openId / chatId / userId
+  text: string
+  allowed: Set<string>
+  rateLimiter: RateLimiter
+  sm: SessionManager
+  getOrCreateWorker: (sessionId: string) => SessionWorker | null
+  cwd: string
+  provider: string
+  model: string
+  sendText: (externalId: string, text: string) => Promise<void>
+  maxLen: number // 飞书 4000 / Telegram 4096 / 企微 2048
+  logPrefix: string // '[feishu]' / '[telegram]' / '[wecom]'
+}
+
+/** 三频道共享的消息处理骨架：白名单→限流→会话→processPrompt→回发。 */
+export async function handleChannelMessage(opts: ChannelMessageOptions): Promise<void> {
+  const {
+    channel,
+    externalId,
+    text,
+    allowed,
+    rateLimiter,
+    sm,
+    getOrCreateWorker,
+    cwd,
+    provider,
+    model,
+    sendText,
+    maxLen,
+    logPrefix,
+  } = opts
+  try {
+    if (!allowed.has(externalId)) return
+    if (!rateLimiter.check(`${channel}:${externalId}`).allowed) return
+
+    const session = sm.getOrCreateByExternalUser(channel, externalId, cwd, provider, model)
+    const worker = getOrCreateWorker(session.id)
+    if (!worker) {
+      await sendText(externalId, '（会话初始化失败，请稍后重试）')
+      return
+    }
+    await worker.processPrompt(text)
+    const result = worker.getLastAssistantContent()
+    await sendText(externalId, result ? result.slice(0, maxLen) : '（无回复）')
+  } catch (err) {
+    console.error(`${logPrefix} message handling failed:`, err)
+    try {
+      await sendText(externalId, '（处理失败，请稍后重试）')
+    } catch {
+      /* 忽略回送失败，不 rethrow */
+    }
+  }
+}

package/src/daemon/feishu/adapter.ts

@@ -4,6 +4,7 @@ import type { FeishuConfig, FeishuTextMessage } from './types.js'
 import type { SessionManager } from '../session-manager'
 import type { SessionWorker } from '../session-worker'
 import type { RateLimiter } from '../rate-limiter'
+import { handleChannelMessage } from '../channel-message.js'
 
 export interface FeishuAdapterDeps {
   sm: SessionManager
@@ -24,33 +25,21 @@ export function createFeishuAdapter(config: FeishuConfig, deps: FeishuAdapterDep
   const allowed = new Set(config.allowedOpenIds)
 
   const onMessage = async (msg: FeishuTextMessage) => {
-    try {
-      if (!allowed.has(msg.openId)) return
-      if (!deps.rateLimiter.check(`feishu:${msg.openId}`).allowed) return
-
-      const session = deps.sm.getOrCreateByExternalUser(
-        'feishu',
-        msg.openId,
-        deps.cwd,
-        deps.provider,
-        deps.model,
-      )
-      const worker = deps.getOrCreateWorker(session.id)
-      if (!worker) {
-        await api.sendText(msg.openId, '（会话初始化失败，请稍后重试）')
-        return
-      }
-      await worker.processPrompt(msg.text)
-      const result = worker.getLastAssistantContent()
-      await api.sendText(msg.openId, result ? result.slice(0, 4000) : '（无回复）')
-    } catch (err) {
-      console.error('[feishu] message handling failed:', err)
-      try {
-        await api.sendText(msg.openId, '（处理失败，请稍后重试）')
-      } catch {
-        /* 忽略回送失败，确保不 rethrow → Feishu 不重试 */
-      }
-    }
+    await handleChannelMessage({
+      channel: 'feishu',
+      externalId: msg.openId,
+      text: msg.text,
+      allowed,
+      rateLimiter: deps.rateLimiter,
+      sm: deps.sm,
+      getOrCreateWorker: deps.getOrCreateWorker,
+      cwd: deps.cwd,
+      provider: deps.provider,
+      model: deps.model,
+      sendText: (id, t) => api.sendText(id, t),
+      maxLen: 4000,
+      logPrefix: '[feishu]',
+    })
   }
 
   const dispatcher = createFeishuEventDispatcher(config, onMessage)

package/src/daemon/index.ts

@@ -27,6 +27,8 @@ import { parseFeishuEnv } from './feishu/env.js'
 import type { FeishuConfig } from './feishu/types.js'
 import { parseTelegramEnv } from './telegram/env.js'
 import type { TelegramConfig } from './telegram/types.js'
+import { parseWecomEnv } from './wecom/env.js'
+import type { WecomConfig } from './wecom/types.js'
 import { loadConfig } from '../config/loader'
 
 const HOME = homedir()
@@ -194,6 +196,20 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
     }
   }
 
+  // 企业微信 remote-control adapter（env 未配置时跳过）
+  const wecomConfig = parseWecomEnv()
+  let wecom: { config: WecomConfig; cwd: string; provider: string; model: string } | undefined
+  if (wecomConfig) {
+    const cfg = loadConfig()
+    const provider = cfg.providers.find((p) => p.status !== 'upcoming') ?? cfg.providers[0]
+    wecom = {
+      config: wecomConfig,
+      cwd: process.env.WECOM_CWD || process.cwd(),
+      provider: provider?.id ?? 'anthropic',
+      model: provider?.models?.[0]?.id ?? 'claude-sonnet-5',
+    }
+  }
+
   // Start HTTP server (Bun.serve starts listening immediately)
   const server = createServer({
     db,
@@ -210,6 +226,7 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
     rateLimiter,
     feishu,
     telegram,
+    wecom,
   })
   activeServer = server
 

package/src/daemon/server.ts

@@ -29,6 +29,9 @@ import type { FeishuConfig } from './feishu/types.js'
 import { createTelegramAdapter } from './telegram/adapter.js'
 import { createTelegramApi } from './telegram/api.js'
 import type { TelegramConfig } from './telegram/types.js'
+import { createWecomAdapter } from './wecom/adapter.js'
+import { createWecomApi } from './wecom/api.js'
+import type { WecomConfig } from './wecom/types.js'
 import { startHeartbeat } from './heartbeat'
 
 interface ServerConfig {
@@ -46,6 +49,7 @@ interface ServerConfig {
   rateLimiter: RateLimiter
   feishu?: { config: FeishuConfig; cwd: string; provider: string; model: string }
   telegram?: { config: TelegramConfig; cwd: string; provider: string; model: string }
+  wecom?: { config: WecomConfig; cwd: string; provider: string; model: string }
 }
 
 interface WsData {
@@ -124,6 +128,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
     rateLimiter,
     feishu,
     telegram,
+    wecom,
   } = config
 
   const wsClients = new Map<string, Set<ServerWebSocket<WsData>>>()
@@ -274,6 +279,19 @@ export function createServer(config: ServerConfig): Server<WsData> {
     : undefined
   telegramAdapter?.start()
 
+  // ── 企业微信 remote-control adapter（长连接，无需 webhook 路由）──
+  const wecomAdapter = wecom
+    ? createWecomAdapter(wecom.config, createWecomApi(wecom.config), {
+        sm,
+        getOrCreateWorker,
+        rateLimiter,
+        cwd: wecom.cwd,
+        provider: wecom.provider,
+        model: wecom.model,
+      })
+    : undefined
+  wecomAdapter?.start()
+
   // ── 心跳式通知：定时扫 pending（goal/schedule），只通知、不自主行动 ──
   const heartbeatSource = {
     listGoals: () => sm.listSessions().flatMap((s) => goalManager.getGoals(s.id)),