@miphamai/cli 0.53.0 → 0.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",

package/src/agent-view/agent-view-manager.ts

@@ -250,17 +250,26 @@ export class AgentViewManager {
     return true
   }
 
+  /**
+   * Permanently remove a single session (any status). Returns true if found.
+   */
+  remove(id: string): boolean {
+    if (!this.sessions.has(id)) return false
+    this.sessions.delete(id)
+    this.sessionOrder = this.sessionOrder.filter((oid) => oid !== id)
+    return true
+  }
+
   /**
    * Remove all completed and failed sessions (cleanup).
    */
   prune(): number {
+    const terminalIds = Array.from(this.sessions.entries())
+      .filter(([, session]) => session.status === 'completed' || session.status === 'failed')
+      .map(([id]) => id)
     let removed = 0
-    for (const [id, session] of this.sessions) {
-      if (session.status === 'completed' || session.status === 'failed') {
-        this.sessions.delete(id)
-        this.sessionOrder = this.sessionOrder.filter((oid) => oid !== id)
-        removed++
-      }
+    for (const id of terminalIds) {
+      if (this.remove(id)) removed++
     }
     return removed
   }

package/src/agent-view/dashboard.tsx

@@ -32,6 +32,8 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
   const [peekingSessionId, setPeekingSessionId] = useState<string | null>(null)
   const [groupBy, setGroupBy] = useState<'status' | 'directory'>('status')
   const [feedback, setFeedback] = useState<string | null>(null)
+  // Bump to force flatList recompute after a session is removed (list membership change).
+  const [version, setVersion] = useState(0)
 
   // Flash a brief feedback message that auto-clears
   const showFeedback = useCallback((msg: string) => {
@@ -87,7 +89,7 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
     }
 
     return result
-  }, [manager, groupBy])
+  }, [manager, groupBy, version])
 
   // Flatten sessions only for navigation (skip headers)
   const sessionsOnly = useMemo(
@@ -140,6 +142,22 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
       return
     }
 
+    // Ctrl+X — permanently remove the selected session
+    if (key.ctrl && input === 'x') {
+      if (sessionsOnly.length === 0) {
+        showFeedback('No sessions to remove')
+        return
+      }
+      const current = sessionsOnly[selectedIndex]
+      if (!current) return
+      manager.remove(current.session.id)
+      setPeekingSessionId(null)
+      setSelectedIndex((prev) => Math.max(0, Math.min(prev, sessionsOnly.length - 2)))
+      setVersion((v) => v + 1)
+      showFeedback(`Removed ${current.session.title || current.session.id}`)
+      return
+    }
+
     if (input === 'j') {
       if (sessionsOnly.length === 0) {
         showFeedback('No sessions to navigate — spawn a background agent first')
@@ -223,7 +241,8 @@ export function AgentViewDashboard({ manager, onAttach, onExit }: DashboardProps
         </Box>
         <Box>
           <Text dimColor>
-            j/k navigate · Space peek · Enter attach · Ctrl+T group · Ctrl+R rename · Esc back
+            j/k navigate · Space peek · Enter attach · Ctrl+T group · Ctrl+R rename · Ctrl+X remove
+            · Esc back
           </Text>
         </Box>
       </Box>

package/src/commands/cd-suggest.ts

@@ -0,0 +1,35 @@
+import { existsSync, readdirSync } from 'node:fs'
+import { dirname, basename, join } from 'node:path'
+
+/**
+ * Suggest existing directories that match a partial `/cd` target.
+ *
+ * `path` must already be tilde-expanded and resolved by the caller (`/cd`
+ * passes the `resolve()`d target). Given a path that does not (fully) exist,
+ * walk up to its nearest existing ancestor and return the subdirectories whose
+ * names prefix-match the trailing segment. Files and non-matching entries are
+ * excluded. Returns `[]` when the path already exists or nothing matches.
+ */
+export function suggestDirectories(path: string): string[] {
+  if (existsSync(path)) return []
+
+  let ancestor = dirname(path)
+  while (!existsSync(ancestor)) {
+    const parent = dirname(ancestor)
+    if (parent === ancestor) return [] // hit filesystem root
+    ancestor = parent
+  }
+
+  const prefix = basename(path)
+  let entries
+  try {
+    entries = readdirSync(ancestor, { withFileTypes: true })
+  } catch {
+    return []
+  }
+
+  return entries
+    .filter((e) => e.isDirectory() && e.name.startsWith(prefix))
+    .map((e) => join(ancestor, e.name))
+    .sort()
+}

package/src/core/claude-md-audit.ts

@@ -0,0 +1,64 @@
+/**
+ * CLAUDE.md audit — find sections whose content the model can infer from the
+ * codebase itself (directory structure, tech stack, dependencies, commit
+ * history, project/submodule catalogs, test counts). Such sections burn
+ * context tokens every session and go stale as the code changes; they are
+ * candidates for the `prompt-exclude` frontmatter.
+ */
+
+export type DerivableReason =
+  'structure' | 'tech-stack' | 'dependencies' | 'commits' | 'catalog' | 'tests'
+
+export interface DerivableSection {
+  heading: string
+  reason: DerivableReason
+}
+
+/** Human-readable hint for each derivable category (diagnostic output). */
+export const DERIVABLE_HINTS: Record<DerivableReason, string> = {
+  structure: 'directory/file structure — inferable from the repo itself',
+  'tech-stack': 'tech stack — inferable from package.json / config',
+  dependencies: 'dependencies — inferable from package.json',
+  commits: 'commit/revision history — inferable from git log',
+  catalog: 'project/submodule catalog — inferable from .gitmodules / directories',
+  tests: 'test counts — inferable from running the suite',
+}
+
+const PATTERNS: Array<{ pattern: RegExp; reason: DerivableReason }> = [
+  {
+    pattern:
+      /目录结构|项目结构|文件结构|directory structure|project structure|file structure|repo structure|monorepo/i,
+    reason: 'structure',
+  },
+  { pattern: /技术栈|tech\s*stack|technology\s*stack/i, reason: 'tech-stack' },
+  { pattern: /依赖关系|依赖清单|dependencies/i, reason: 'dependencies' },
+  {
+    pattern: /最近提交|recent\s*commit|修订历史|revision\s*history|changelog|变更记录|变更历史/i,
+    reason: 'commits',
+  },
+  {
+    pattern: /项目一览|项目清单|项目列表|子模块清单|submodule\s*(list|catalog)|catalog/i,
+    reason: 'catalog',
+  },
+  { pattern: /测试矩阵|test\s*matrix|测试覆盖|coverage/i, reason: 'tests' },
+]
+
+/**
+ * Return `##`/`###` headings whose title matches a derivable-content pattern,
+ * in document order. Headings without a match are ignored.
+ */
+export function findDerivableSections(content: string): DerivableSection[] {
+  const found: DerivableSection[] = []
+  for (const line of content.split('\n')) {
+    const m = line.match(/^(#{2,3})\s+(.+?)\s*$/)
+    if (!m) continue
+    const heading = m[2]!.trim()
+    for (const { pattern, reason } of PATTERNS) {
+      if (pattern.test(heading)) {
+        found.push({ heading, reason })
+        break
+      }
+    }
+  }
+  return found
+}

package/src/daemon/backoff.ts

@@ -0,0 +1,4 @@
+/** 指数退避，封顶 30s。三频道（telegram/wecom/dingtalk）重连共享。 */
+export function nextBackoff(currentMs: number): number {
+  return Math.min(currentMs * 2, 30_000)
+}

package/src/daemon/channel-message.ts

@@ -3,7 +3,7 @@ import type { SessionWorker } from './session-worker'
 import type { RateLimiter } from './rate-limiter'
 
 export interface ChannelMessageOptions {
-  channel: string // 'feishu' | 'telegram' | 'wecom'
+  channel: string // 'feishu' | 'telegram' | 'wecom' | 'dingtalk'
   externalId: string // openId / chatId / userId
   text: string
   allowed: Set<string>
@@ -14,11 +14,11 @@ export interface ChannelMessageOptions {
   provider: string
   model: string
   sendText: (externalId: string, text: string) => Promise<void>
-  maxLen: number // 飞书 4000 / Telegram 4096 / 企微 2048
+  maxLen: number // 飞书 4000 / Telegram 4096 / 企微 2048 / 钉钉 2000
   logPrefix: string // '[feishu]' / '[telegram]' / '[wecom]'
 }
 
-/** 三频道共享的消息处理骨架：白名单→限流→会话→processPrompt→回发。 */
+/** 四频道共享的消息处理骨架：白名单→限流→会话→processPrompt→回发。 */
 export async function handleChannelMessage(opts: ChannelMessageOptions): Promise<void> {
   const {
     channel,

package/src/daemon/dingtalk/adapter.ts

@@ -0,0 +1,62 @@
+import type { DingtalkApi } from './api.js'
+import type { DingtalkConfig, DingtalkMessage } from './types.js'
+import type { SessionManager } from '../session-manager'
+import type { SessionWorker } from '../session-worker'
+import type { RateLimiter } from '../rate-limiter'
+import { startDingtalkWs } from './ws-client.js'
+import { handleChannelMessage } from '../channel-message.js'
+
+export interface DingtalkAdapterDeps {
+  sm: SessionManager
+  getOrCreateWorker: (sessionId: string) => SessionWorker | null
+  rateLimiter: RateLimiter
+  cwd: string
+  provider: string
+  model: string
+}
+
+export interface DingtalkAdapter {
+  start(): () => void
+  handleMessage(msg: DingtalkMessage): Promise<void>
+  isAllowed(staffId: string): boolean
+}
+
+export function createDingtalkAdapter(
+  config: DingtalkConfig,
+  api: DingtalkApi,
+  deps: DingtalkAdapterDeps,
+): DingtalkAdapter {
+  const allowed = new Set(config.allowedStaffIds)
+  let stopWs: (() => void) | null = null
+
+  async function handleMessage(msg: DingtalkMessage): Promise<void> {
+    await handleChannelMessage({
+      channel: 'dingtalk',
+      externalId: msg.staffId,
+      text: msg.text,
+      allowed,
+      rateLimiter: deps.rateLimiter,
+      sm: deps.sm,
+      getOrCreateWorker: deps.getOrCreateWorker,
+      cwd: deps.cwd,
+      provider: deps.provider,
+      model: deps.model,
+      // 钉钉回发走每条消息自带的 sessionWebhook（非持久 userId 路由）
+      sendText: async (_staffId, text) => {
+        await api.reply(msg.sessionWebhook, text)
+      },
+      maxLen: 2000,
+      logPrefix: '[dingtalk]',
+    })
+  }
+
+  return {
+    handleMessage,
+    isAllowed: (staffId) => allowed.has(staffId),
+    start() {
+      if (stopWs) return stopWs
+      stopWs = startDingtalkWs(api, handleMessage)
+      return stopWs
+    },
+  }
+}

package/src/daemon/dingtalk/api.ts

@@ -0,0 +1,120 @@
+import type { DingtalkConfig, DingtalkMessage } from './types.js'
+
+const GATEWAY_URL = 'https://api.dingtalk.com/v1.0/gateway/connections/open'
+
+export interface DingtalkApi {
+  register(): Promise<{ endpoint: string; ticket: string }>
+  open(endpoint: string, ticket: string): WebSocket
+  reply(sessionWebhook: string, text: string): Promise<void>
+  parseMessage(frame: unknown): DingtalkMessage | null
+  isPing(frame: unknown): boolean
+  ack(ws: WebSocket, frame: unknown): void
+  pong(ws: WebSocket, frame: unknown): void
+}
+
+/** 回帧信封：code 200 + 回显 headers.messageId。ack 与 pong 共用。 */
+function sendResponse(ws: WebSocket, frame: unknown, data: unknown): void {
+  const f = frame as { headers?: { messageId?: string } }
+  ws.send(
+    JSON.stringify({
+      code: 200,
+      headers: { contentType: 'application/json', messageId: f?.headers?.messageId ?? '' },
+      message: 'OK',
+      data,
+    }),
+  )
+}
+
+/**
+ * 钉钉 Stream Mode 协议 codec。零依赖：HTTP 用裸 fetch（register + 回发），
+ * WebSocket 用 globalThis.WebSocket（Node 22+ / Bun 原生）。ticket 一次性且
+ * 90s 过期，由 ws-client 每次重连前重新 register。
+ */
+export function createDingtalkApi(
+  config: DingtalkConfig,
+  fetchImpl: typeof fetch = fetch,
+): DingtalkApi {
+  return {
+    async register() {
+      const res = await fetchImpl(GATEWAY_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          clientId: config.clientId,
+          clientSecret: config.clientSecret,
+          subscriptions: [{ type: 'CALLBACK', topic: '/v1.0/im/bot/messages/get' }],
+          ua: 'mipham-code',
+        }),
+      })
+      if (!res.ok) throw new Error(`dingtalk gateway register ${res.status}`)
+      const data = (await res.json()) as { endpoint?: string; ticket?: string }
+      if (!data.endpoint || !data.ticket) {
+        throw new Error('dingtalk gateway: missing endpoint/ticket')
+      }
+      return { endpoint: data.endpoint, ticket: data.ticket }
+    },
+
+    open(endpoint, ticket) {
+      return new WebSocket(`${endpoint}?ticket=${encodeURIComponent(ticket)}`)
+    },
+
+    async reply(sessionWebhook, text) {
+      if (!sessionWebhook) return
+      const res = await fetchImpl(sessionWebhook, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ msgtype: 'text', text: { content: text } }),
+      })
+      if (!res.ok) throw new Error(`dingtalk reply ${res.status}`)
+      const data = (await res.json()) as { errcode?: number; errmsg?: string }
+      if (data.errcode != null && data.errcode !== 0) {
+        throw new Error(`dingtalk reply errcode=${data.errcode}: ${data.errmsg ?? 'unknown'}`)
+      }
+    },
+
+    parseMessage(frame) {
+      if (!frame || typeof frame !== 'object') return null
+      const f = frame as { type?: string; data?: unknown }
+      if (f.type !== 'CALLBACK' || typeof f.data !== 'string') return null
+      let payload: {
+        msgtype?: string
+        text?: { content?: string }
+        senderStaffId?: string
+        senderId?: string
+        conversationId?: string
+        msgId?: string
+        sessionWebhook?: string
+      }
+      try {
+        payload = JSON.parse(f.data)
+      } catch {
+        return null
+      }
+      if (payload?.msgtype !== 'text') return null
+      const text = payload?.text?.content?.trim()
+      if (!text) return null
+      const staffId = payload?.senderStaffId ?? payload?.senderId
+      if (!staffId) return null
+      return {
+        staffId,
+        conversationId: payload?.conversationId ?? '',
+        msgId: payload?.msgId ?? '',
+        text,
+        sessionWebhook: payload?.sessionWebhook ?? '',
+      }
+    },
+
+    isPing(frame) {
+      const f = frame as { type?: string; headers?: { topic?: string } }
+      return f?.type === 'SYSTEM' && f?.headers?.topic === 'ping'
+    },
+
+    ack(ws, frame) {
+      sendResponse(ws, frame, '{"response": null}')
+    },
+
+    pong(ws, frame) {
+      sendResponse(ws, frame, (frame as { data?: unknown }).data)
+    },
+  }
+}

package/src/daemon/dingtalk/env.ts

@@ -0,0 +1,16 @@
+import type { DingtalkConfig } from './types.js'
+
+/** fail-closed：缺 clientId 或 clientSecret → null（daemon 不启用钉钉）。 */
+export function parseDingtalkEnv(): DingtalkConfig | null {
+  const clientId = process.env.DINGTALK_CLIENT_ID
+  const clientSecret = process.env.DINGTALK_CLIENT_SECRET
+  if (!clientId || !clientSecret) return null
+  return {
+    clientId,
+    clientSecret,
+    allowedStaffIds: (process.env.DINGTALK_ALLOWED_STAFF_IDS || '')
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean),
+  }
+}

package/src/daemon/dingtalk/types.ts

@@ -0,0 +1,13 @@
+export interface DingtalkConfig {
+  clientId: string
+  clientSecret: string
+  allowedStaffIds: string[] // 白名单（钉钉 senderStaffId / senderId）
+}
+
+export interface DingtalkMessage {
+  staffId: string // 发消息用户（senderStaffId，回退 senderId）
+  conversationId: string // 会话 id
+  msgId: string // 消息 id（业务侧）
+  text: string // 文本内容
+  sessionWebhook: string // 回发路由（机器人 sessionWebhook URL）
+}

package/src/daemon/dingtalk/ws-client.ts

@@ -0,0 +1,81 @@
+import type { DingtalkApi } from './api.js'
+import type { DingtalkMessage } from './types.js'
+import { nextBackoff } from '../backoff.js'
+
+/**
+ * 钉钉 Stream 长连接生命周期：register（HTTP 拿 endpoint+ticket）→ 建连 →
+ * 服务端 ping/pong → 消息回调（parse→ack→onMessage）→ 断开重连。ticket 一次性
+ * 且 90s 过期，故每次重连前必须重新 register。返回 stop。
+ */
+export function startDingtalkWs(
+  api: DingtalkApi,
+  onMessage: (msg: DingtalkMessage) => Promise<void>,
+): () => void {
+  let stopped = false
+  let ws: WebSocket | null = null
+  let backoffMs = 1000
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null
+
+  function clearReconnect() {
+    if (reconnectTimer) clearTimeout(reconnectTimer)
+    reconnectTimer = null
+  }
+
+  function scheduleReconnect() {
+    if (stopped) return
+    reconnectTimer = setTimeout(() => void connect(), backoffMs)
+    backoffMs = nextBackoff(backoffMs)
+    ;(reconnectTimer as unknown as { unref?: () => void }).unref?.()
+  }
+
+  async function connect() {
+    if (stopped) return
+    let endpoint: string
+    let ticket: string
+    try {
+      ;({ endpoint, ticket } = await api.register())
+    } catch {
+      scheduleReconnect()
+      return
+    }
+    if (stopped) return
+    ws = api.open(endpoint, ticket)
+    ws.onopen = () => {
+      backoffMs = 1000
+    }
+    ws.onmessage = (ev) => {
+      let frame: unknown
+      try {
+        frame = JSON.parse(ev.data as string)
+      } catch {
+        return
+      }
+      if (api.isPing(frame)) {
+        if (ws) api.pong(ws, frame)
+        return
+      }
+      const msg = api.parseMessage(frame)
+      if (msg) {
+        if (ws) api.ack(ws, frame)
+        void onMessage(msg).catch(() => {})
+      }
+    }
+    ws.onclose = () => {
+      ws = null
+      scheduleReconnect()
+    }
+  }
+
+  void connect()
+  return () => {
+    stopped = true
+    clearReconnect()
+    if (ws) {
+      try {
+        ws.close()
+      } catch {
+        /* 连接尚未建立时 close 可能抛错，忽略 */
+      }
+    }
+  }
+}

package/src/daemon/index.ts

@@ -29,6 +29,8 @@ 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 { parseDingtalkEnv } from './dingtalk/env.js'
+import type { DingtalkConfig } from './dingtalk/types.js'
 import { loadConfig } from '../config/loader'
 
 const HOME = homedir()
@@ -210,6 +212,20 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
     }
   }
 
+  // 钉钉 remote-control adapter（Stream 长连接，env 未配置时跳过）
+  const dingtalkConfig = parseDingtalkEnv()
+  let dingtalk: { config: DingtalkConfig; cwd: string; provider: string; model: string } | undefined
+  if (dingtalkConfig) {
+    const cfg = loadConfig()
+    const provider = cfg.providers.find((p) => p.status !== 'upcoming') ?? cfg.providers[0]
+    dingtalk = {
+      config: dingtalkConfig,
+      cwd: process.env.DINGTALK_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,
@@ -227,6 +243,7 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
     feishu,
     telegram,
     wecom,
+    dingtalk,
   })
   activeServer = server
 

package/src/daemon/server.ts

@@ -32,6 +32,9 @@ 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 { createDingtalkAdapter } from './dingtalk/adapter.js'
+import { createDingtalkApi } from './dingtalk/api.js'
+import type { DingtalkConfig } from './dingtalk/types.js'
 import { startHeartbeat } from './heartbeat'
 
 interface ServerConfig {
@@ -50,6 +53,7 @@ interface ServerConfig {
   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 }
+  dingtalk?: { config: DingtalkConfig; cwd: string; provider: string; model: string }
 }
 
 interface WsData {
@@ -129,6 +133,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
     feishu,
     telegram,
     wecom,
+    dingtalk,
   } = config
 
   const wsClients = new Map<string, Set<ServerWebSocket<WsData>>>()
@@ -292,6 +297,19 @@ export function createServer(config: ServerConfig): Server<WsData> {
     : undefined
   wecomAdapter?.start()
 
+  // ── 钉钉 remote-control adapter（Stream 长连接，无需 webhook 路由）──
+  const dingtalkAdapter = dingtalk
+    ? createDingtalkAdapter(dingtalk.config, createDingtalkApi(dingtalk.config), {
+        sm,
+        getOrCreateWorker,
+        rateLimiter,
+        cwd: dingtalk.cwd,
+        provider: dingtalk.provider,
+        model: dingtalk.model,
+      })
+    : undefined
+  dingtalkAdapter?.start()
+
   // ── 心跳式通知：定时扫 pending（goal/schedule），只通知、不自主行动 ──
   const heartbeatSource = {
     listGoals: () => sm.listSessions().flatMap((s) => goalManager.getGoals(s.id)),

package/src/daemon/telegram/poller.ts

@@ -1,5 +1,6 @@
 import type { TelegramApi } from './api.js'
 import type { TelegramMessage } from './types.js'
+import { nextBackoff } from '../backoff.js'
 
 /** 从 update 提取文本消息；非文本/缺 message → null。chat.id 统一字符串化比对（id < 2^53；超范围 bigint 后续再引入）。 */
 export function extractTextMessage(update: unknown): TelegramMessage | null {
@@ -16,11 +17,6 @@ export function nextOffset(updates: Array<{ update_id?: number }>, prevOffset: n
   return Math.max(...updates.map((u) => u.update_id ?? prevOffset)) + 1
 }
 
-/** 指数退避，封顶 30s。 */
-export function nextBackoff(currentMs: number): number {
-  return Math.min(currentMs * 2, 30_000)
-}
-
 /** 长轮询循环（unref 不阻退出）。返回 stop 函数。循环行为由 Task 7 集成测试覆盖。 */
 export function startTelegramPoller(
   api: TelegramApi,

package/src/daemon/wecom/ws-client.ts

@@ -1,10 +1,6 @@
 import type { WecomApi } from './api.js'
 import type { WecomMessage } from './types.js'
-
-/** 指数退避，封顶 30s。与 telegram poller.nextBackoff 同源。 */
-export function nextBackoff(currentMs: number): number {
-  return Math.min(currentMs * 2, 30_000)
-}
+import { nextBackoff } from '../backoff.js'
 
 /** WebSocket 长连接生命周期：建连→subscribe→心跳→消息回调→断开重连。返回 stop。 */
 export function startWecomWs(

package/src/i18n-core/locales/en-US.json

@@ -563,6 +563,7 @@
     "cd": {
       "usage": "Usage: /cd <path>\n\nChange the session working directory.\nExample: /cd ~/projects/my-app\n\nCurrent: {cwd}",
       "not_found": "❌ Directory not found: {path}",
+      "suggestions": "Did you mean:",
       "failed": "❌ Failed to change directory: {error}",
       "title": "── Directory Changed ──",
       "content": "New CWD: {path}\n\nThe AI will now work relative to this directory.\nNote: This changes the filesystem root for tools like Read, Write, Bash."
@@ -594,7 +595,10 @@
       "git_section": "── Git ──",
       "no_git": "  (not a git repository or git not available)",
       "skills_section": "── Skills ──",
-      "skills_unavailable": "  (skills info unavailable)"
+      "skills_unavailable": "  (skills info unavailable)",
+      "audit_section": "── CLAUDE.md Audit ──",
+      "audit_clean": "  ✓ no code-derivable sections found",
+      "audit_found": "Add the sections above to the `prompt-exclude` frontmatter to stop sending them to the model."
     },
     "plugins": {
       "unavailable": "PluginManager not available in this session.",

package/src/i18n-core/locales/zh-CN.json

@@ -563,6 +563,7 @@
     "cd": {
       "usage": "用法: /cd <path>\n\n更改会话工作目录。\n示例: /cd ~/projects/my-app\n\n当前: {cwd}",
       "not_found": "❌ 目录未找到: {path}",
+      "suggestions": "你是想找：",
       "failed": "❌ 更改目录失败: {error}",
       "title": "── 目录已更改 ──",
       "content": "新目录: {path}\n\nAI 将相对于此目录工作。\n注意: 这会更改 Read、Write、Bash 等工具的文件系统根路径。"
@@ -594,7 +595,10 @@
       "git_section": "── Git ──",
       "no_git": "  （不是 git 仓库或 git 不可用）",
       "skills_section": "── 技能 ──",
-      "skills_unavailable": "  （技能信息不可用）"
+      "skills_unavailable": "  （技能信息不可用）",
+      "audit_section": "── CLAUDE.md 审计 ──",
+      "audit_clean": "  ✓ 未发现可从代码推断的冗余章节",
+      "audit_found": "将上述章节加入 `prompt-exclude` frontmatter，可停止发送给模型、节省 token。"
     },
     "plugins": {
       "unavailable": "当前会话中 PluginManager 不可用。",

package/src/mcp/client.ts

@@ -161,8 +161,8 @@ export class McpClient {
     if (existing?.status === 'connected') return
 
     const transport: StdioTransport | HttpTransport = config.url
-      ? new HttpTransport()
-      : new StdioTransport()
+      ? new HttpTransport(undefined, config.request_timeout_ms)
+      : new StdioTransport(config.request_timeout_ms)
     const protocol = new McpProtocol(transport)
 
     const connection: ActiveConnection = {

package/src/mcp/http-transport.ts

@@ -1,10 +1,9 @@
 import type { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification, JsonRpcError } from './types'
 import type { Transport, NotificationHandler } from './transport'
+import { DEFAULT_REQUEST_TIMEOUT_MS, requestTimeoutError } from './transport'
 
 type FetchFn = (input: string, init?: RequestInit) => Promise<Response>
 
-const REQUEST_TIMEOUT_MS = 60_000
-
 /**
  * Merge multiple SSE `data:` events into a single JSON-RPC result.
  *
@@ -74,7 +73,10 @@ export class HttpTransport implements Transport {
   private closed = false
   private notificationHandlers: NotificationHandler[] = []
 
-  constructor(private fetchImpl: FetchFn = fetch as unknown as FetchFn) {}
+  constructor(
+    private fetchImpl: FetchFn = fetch as unknown as FetchFn,
+    private requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+  ) {}
 
   async start(
     url: string,
@@ -107,7 +109,7 @@ export class HttpTransport implements Transport {
     }
 
     const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS)
+    const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs)
 
     try {
       const response = await this.fetchImpl(this.url, {
@@ -142,6 +144,11 @@ export class HttpTransport implements Transport {
         throw new Error(`MCP error ${json.error.code}: ${json.error.message}`)
       }
       return json.result
+    } catch (err) {
+      if (controller.signal.aborted) {
+        throw requestTimeoutError(method, this.requestTimeoutMs)
+      }
+      throw err
     } finally {
       clearTimeout(timer)
     }

package/src/mcp/oauth.ts

@@ -4,6 +4,7 @@ import { createServer, Server } from 'node:http'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import type { McpServerConfig } from '../shared/types'
 import { TokenStore } from './token-store'
+import { fetchWithRetry } from '../providers/fetch-utils'
 import { createT } from '../i18n-core/t'
 import enUS from '../i18n-core/locales/en-US.json'
 import zhCN from '../i18n-core/locales/zh-CN.json'
@@ -148,15 +149,22 @@ export class OAuthClient {
       throw new Error(`No refresh token available for "${serverName}"`)
     }
     const auth = config.auth!
-    const response = await fetch(auth.tokenUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      body: new URLSearchParams({
-        grant_type: 'refresh_token',
-        refresh_token: saved.refreshToken,
-        client_id: auth.clientId,
-      }).toString(),
-    })
+    // A single failed refresh is often a transient network/server error, not a
+    // real revocation — retry (5xx/429/network) before forcing PKCE. 4xx (e.g.
+    // invalid_grant) is a genuine revocation and falls through to PKCE directly.
+    const response = await fetchWithRetry(
+      auth.tokenUrl,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+          grant_type: 'refresh_token',
+          refresh_token: saved.refreshToken,
+          client_id: auth.clientId,
+        }).toString(),
+      },
+      { maxRetries: 1, baseDelay: 300 },
+    )
     if (!response.ok) {
       this.store.delete(serverName)
       const fresh = await this.executePkceFlow(config)

package/src/mcp/transport.ts

@@ -19,7 +19,12 @@ export interface Transport {
   isConnected(): boolean
 }
 
-const REQUEST_TIMEOUT_MS = 60_000
+export const DEFAULT_REQUEST_TIMEOUT_MS = 60_000
+
+/** Shared timeout error for both stdio and HTTP transports. */
+export function requestTimeoutError(method: string, ms: number): Error {
+  return new Error(`MCP request timeout: ${method} (${ms}ms)`)
+}
 
 // ── Environment variable security: block sensitive vars from MCP subprocess ──
 //
@@ -69,6 +74,7 @@ function buildProcEnv(extra?: Record<string, string>): Record<string, string> {
  * Uses Node.js child_process for portability across Bun and Node runtimes.
  */
 export class StdioTransport implements Transport {
+  constructor(private requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {}
   private proc: ChildProcess | null = null
   private msgId = 0
   private pending = new Map<
@@ -169,8 +175,8 @@ export class StdioTransport implements Transport {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id)
-        reject(new Error(`MCP request timeout: ${method} (${REQUEST_TIMEOUT_MS}ms)`))
-      }, REQUEST_TIMEOUT_MS)
+        reject(requestTimeoutError(method, this.requestTimeoutMs))
+      }, this.requestTimeoutMs)
 
       this.pending.set(id, { resolve, reject, timer })
 

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.53.0' as const
+export const PACKAGE_VERSION = '0.54.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const

package/src/shared/types.ts

@@ -176,6 +176,8 @@ export interface McpServerConfig {
   /** HTTP: extra request headers (e.g. Authorization). */
   headers?: Record<string, string>
   env?: Record<string, string>
+  /** Per-server tool-call request timeout (ms). Overrides the 60s default. */
+  request_timeout_ms?: number
   auth?: {
     type: 'oauth'
     authorizationUrl: string

package/src/ui/commands.ts

@@ -11,6 +11,8 @@ import type { PluginManager } from '../plugin/plugin-manager'
 import type { Message } from '../shared/types.js'
 import { McpClient } from '../mcp/client'
 import { buildCapabilityReport } from '../core/capability-inventory'
+import { InstructionsLoader } from '../core/instructions'
+import { findDerivableSections, DERIVABLE_HINTS } from '../core/claude-md-audit'
 import { runCrsiModification, approvePending, rejectPending, hasPending } from '../core/crsi-modify'
 import {
   produceCrsiProposal,
@@ -57,6 +59,7 @@ import {
 } from '../commands/project.js'
 import { themeCmd, releaseNotesCmd, ideCmd, terminalSetupCmd } from '../commands/environment.js'
 import { commitCmd, pushCmd, prCmd, issueCmd } from '../commands/git.js'
+import { suggestDirectories } from '../commands/cd-suggest.js'
 import { keysCmd } from '../commands/keys'
 import { workflowViewCmd, workflowWatchCmd } from '../commands/workflow-view.js'
 import { execSync } from 'node:child_process'
@@ -2905,6 +2908,34 @@ const doctorCmd: CommandHandler = async (ctx) => {
     }
   }
 
+  // CLAUDE.md audit — flag sections the model can infer from the codebase
+  try {
+    const loader = new InstructionsLoader()
+    loader.loadAll(process.cwd())
+    const claudeFiles = loader.list().filter((f) => f.path.endsWith('CLAUDE.md'))
+
+    lines.push('')
+    lines.push(t('commands.doctor.audit_section'))
+    let found = false
+    for (const file of claudeFiles) {
+      const sections = findDerivableSections(file.content)
+      if (sections.length === 0) continue
+      found = true
+      lines.push(`  ${file.path}`)
+      for (const s of sections) {
+        lines.push(`    - "${s.heading}" — ${DERIVABLE_HINTS[s.reason]}`)
+      }
+    }
+    if (!found) {
+      lines.push(t('commands.doctor.audit_clean'))
+    } else {
+      lines.push('')
+      lines.push(t('commands.doctor.audit_found'))
+    }
+  } catch {
+    // best-effort — skip the audit on any failure
+  }
+
   return { content: lines.join('\n') }
 }
 
@@ -3183,7 +3214,12 @@ const cdCmd: CommandHandler = async (ctx, args) => {
   const resolved = resolve(target.replace(/^~/, process.env.HOME || '~'))
 
   if (!existsSync(resolved)) {
-    return { content: t('commands.cd.not_found', { path: resolved }) }
+    const suggestions = suggestDirectories(resolved)
+    let content = t('commands.cd.not_found', { path: resolved })
+    if (suggestions.length > 0) {
+      content += `\n\n${t('commands.cd.suggestions')}\n${suggestions.map((s) => `  ${s}`).join('\n')}`
+    }
+    return { content }
   }
 
   try {