@miphamai/cli 0.62.0 → 0.64.0

package/src/core/eval-harness.ts

@@ -19,7 +19,7 @@ import { ConstitutionLoader, DEFAULT_CONSTITUTION } from './constitution-loader'
 import { ErrorSignatureDB } from './error-signature-db'
 import { PreFlightChecker } from './preflight-checker'
 import { RedTeam } from './red-team'
-import { isProtectedPath, validateBlastRadius } from './crsi-sandbox'
+import { isProtectedPath, validateBlastRadius, PROTECTED_CRITICAL_FILES } from './crsi-sandbox'
 import { produceRuleProposal, MANAGED_RULES_FILE } from './crsi-producer'
 import type { CrsiSignal } from './crsi-producer'
 import { loadBehaviorTasks, judgeBehaviorTask } from './behavior-tasks'
@@ -46,13 +46,17 @@ export interface EvalReport {
 
 const SCORES_FILE = join(homedir(), '.mipham', 'crsi', 'eval-scores.jsonl')
 
-/** 追加一次评估分数到 rewards 日志。 */
-export function appendEvalScore(report: EvalReport): void {
+/** 追加一次评估分数到 rewards 日志（按奖励函数名键控）。 */
+export function appendEvalScore(
+  name: string,
+  report: { score: number; passed: number; total: number },
+): void {
   try {
     mkdirSync(join(homedir(), '.mipham', 'crsi'), { recursive: true })
     appendFileSync(
       SCORES_FILE,
       JSON.stringify({
+        name,
         timestamp: new Date().toISOString(),
         score: report.score,
         passed: report.passed,
@@ -65,14 +69,16 @@ export function appendEvalScore(report: EvalReport): void {
   }
 }
 
-/** 读取最近一次评估分数（无记录时返回 null）。 */
-export function getLastEvalScore(): number | null {
+/** 读取某奖励函数最近一次分数（无记录时返回 null）。旧无 name 记录自然跳过。 */
+export function getLastEvalScore(name: string): number | null {
   try {
     if (!existsSync(SCORES_FILE)) return null
     const lines = readFileSync(SCORES_FILE, 'utf-8').trim().split('\n').filter(Boolean)
-    if (lines.length === 0) return null
-    const last = JSON.parse(lines[lines.length - 1]!) as { score?: number }
-    return typeof last.score === 'number' ? last.score : null
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const rec = JSON.parse(lines[i]!) as { name?: string; score?: number }
+      if (rec.name === name && typeof rec.score === 'number') return rec.score
+    }
+    return null
   } catch {
     return null
   }
@@ -167,6 +173,15 @@ export function runEval(): EvalReport {
     results.push({ id, description: `受保护路径被拒: ${path}`, passed: isProtectedPath(path) })
   }
 
+  // ── 语义边界完整性（ground truth：金丝雀关键机制文件全覆盖） ──
+  const unprotected = PROTECTED_CRITICAL_FILES.filter((f) => !isProtectedPath(f))
+  results.push({
+    id: 'protection-completeness',
+    description: '语义保护边界覆盖全部关键机制文件（评估器 + 核心机制）',
+    passed: unprotected.length === 0,
+    ...(unprotected.length > 0 ? { detail: `未保护: ${unprotected.join(', ')}` } : {}),
+  })
+
   // ── 完整覆盖闸（ground truth：未声明 blast radius 的 proposal 被 fail-closed 拒绝） ──
   results.push({
     id: 'blast-radius-gate',

package/src/core/hooks-executor.ts

@@ -49,7 +49,8 @@ function executeCommand(cfg: HookConfig, ctx: HookContext): HookResult {
     }
 
     // Non-zero exit: check for block signal (exit code 2)
-    const stderr = result.stderr?.toString() || ''
+    // 截断 stderr 防 MB 级 hook 输出溢出会话（对齐 HTTP hook 的 slice(0,2000)）。
+    const stderr = (result.stderr?.toString() || '').slice(0, 2000)
 
     if (result.status === 2) {
       return {

package/src/core/improvement-track.ts

@@ -0,0 +1,144 @@
+// CRSI 改进轨：噪声自适应改进判定 + 台账 + pending verdict 闸。
+// A1 不破：verdict / minEffect / 改进率全是确定性算术（均值/标准差/阈值/Wilson），无 LLM 裁判。
+import { appendFileSync, readFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+import type { SkillDeltaSample } from './task-performance'
+
+export type ImprovementVerdict = 'improved' | 'regressed' | 'inconclusive'
+
+export const MIN_EFFECT_FLOOR = 20
+export const NOISE_K = 2
+export const FALSE_POSITIVE_BASELINE = 0.05
+
+export interface ImprovementReport {
+  skillName: string
+  changeSet: string[]
+  causal: boolean
+  baselineScores: number[]
+  postScores: number[]
+  deltaMean: number
+  noise: number
+  minEffect: number
+  verdict: ImprovementVerdict
+}
+
+export interface ImprovementRecord extends ImprovementReport {
+  id: string
+  timestamp: string
+}
+
+// ── 纯函数 ──
+
+export function computeMinEffect(noise: number): number {
+  return Math.max(MIN_EFFECT_FLOOR, NOISE_K * noise)
+}
+
+export function classifyDelta(deltaMean: number, minEffect: number): ImprovementVerdict {
+  if (deltaMean <= -minEffect) return 'regressed'
+  if (deltaMean >= minEffect) return 'improved'
+  return 'inconclusive'
+}
+
+function mean(xs: number[]): number {
+  return xs.length === 0 ? 0 : xs.reduce((a, b) => a + b, 0) / xs.length
+}
+
+function stdDev(xs: number[]): number {
+  if (xs.length < 2) return 0
+  const m = mean(xs)
+  const variance = xs.reduce((a, b) => a + (b - m) ** 2, 0) / (xs.length - 1)
+  return Math.sqrt(variance)
+}
+
+export function buildImprovementReport(
+  sample: SkillDeltaSample,
+  changeSet: string[],
+): ImprovementReport {
+  const deltaMean = mean(sample.postScores) - mean(sample.baselineScores)
+  const noise = stdDev(sample.baselineScores)
+  const minEffect = computeMinEffect(noise)
+  const verdict = classifyDelta(deltaMean, minEffect)
+  return {
+    skillName: sample.skillName,
+    changeSet,
+    causal: changeSet.length === 1,
+    baselineScores: sample.baselineScores,
+    postScores: sample.postScores,
+    deltaMean,
+    noise,
+    minEffect,
+    verdict,
+  }
+}
+
+/** Wilson score 区间（z 默认 1.96 = 95%）。n=0 → {0,0}。 */
+export function wilsonInterval(
+  improved: number,
+  total: number,
+  z = 1.96,
+): { lo: number; hi: number } {
+  if (total === 0) return { lo: 0, hi: 0 }
+  const p = improved / total
+  const n = total
+  const denom = 1 + (z * z) / n
+  const center = (p + (z * z) / (2 * n)) / denom
+  const half = (z * Math.sqrt((p * (1 - p)) / n + (z * z) / (4 * n * n))) / denom
+  return { lo: center - half, hi: center + half }
+}
+
+export function improvementRate(records: ImprovementRecord[]): {
+  total: number
+  improved: number
+  rate: number
+  lo: number
+  hi: number
+} {
+  const total = records.length
+  const improved = records.filter((r) => r.verdict === 'improved').length
+  const { lo, hi } = wilsonInterval(improved, total)
+  return { total, improved, rate: total === 0 ? 0 : improved / total, lo, hi }
+}
+
+/** 循环有效性：改进率 Wilson 95% CI 下界 > 假阳性基线（默认 5%）。 */
+export function improvementSignalStrong(records: ImprovementRecord[]): boolean {
+  const { lo } = improvementRate(records)
+  return records.length > 0 && lo > FALSE_POSITIVE_BASELINE
+}
+
+// ── 台账 ──
+
+export function improvementPath(): string {
+  return join(homedir(), '.mipham', 'crsi', 'improvements.jsonl')
+}
+
+export function appendImprovement(record: ImprovementRecord): void {
+  const file = improvementPath()
+  mkdirSync(join(homedir(), '.mipham', 'crsi'), { recursive: true })
+  appendFileSync(file, JSON.stringify(record) + '\n', 'utf-8')
+}
+
+export function readImprovements(): ImprovementRecord[] {
+  const file = improvementPath()
+  if (!existsSync(file)) return []
+  return readFileSync(file, 'utf-8')
+    .split('\n')
+    .filter((line) => line.trim() !== '')
+    .map((line) => JSON.parse(line) as ImprovementRecord)
+}
+
+// ── pending verdict 闸（倒退才拦） ──
+
+let pendingVerdict: ImprovementVerdict | null = null
+
+export function setPendingVerdict(v: ImprovementVerdict | null): void {
+  pendingVerdict = v
+}
+
+export function getPendingVerdict(): ImprovementVerdict | null {
+  return pendingVerdict
+}
+
+export function shouldBlockApproval(v: ImprovementVerdict): boolean {
+  return v === 'regressed'
+}

package/src/core/reward-fn.ts

@@ -0,0 +1,44 @@
+// CRSI RewardFn 接口——reward function = policy→feedback 抽象。
+// 统一「给一个 policy 打分」：机制哨兵（runEval）与任务表现（runTaskPerformance）
+// 都 conform 成 RewardFn，自改进环的 verify 阶段可对任意奖励源比分数、判退化。
+import type { Llm } from '../providers/llm'
+import { runEval } from './eval-harness'
+import { runTaskPerformance } from './task-performance'
+
+/** 奖励函数统一输出的「分数」形状——所有 RewardFn 的 evaluate 都产出它。 */
+export interface ScoreReport {
+  total: number
+  passed: number
+  score: number // 0-100
+  failures: string[]
+}
+
+/** 奖励函数（reward function = policy→feedback）：一个具名、可替换的打分器。 */
+export interface RewardFn {
+  name: string
+  description: string
+  evaluate(): Promise<ScoreReport> | ScoreReport
+}
+
+/** 机制哨兵：冻结契约评当前仓库机制代码（无 LLM，同步）。 */
+export function mechanismSentinel(): RewardFn {
+  return {
+    name: 'mechanism-sentinel',
+    description: '冻结契约评当前仓库机制代码（无 LLM）',
+    evaluate: () => runEval(),
+  }
+}
+
+/** 任务表现：LLM 生成代码 + 冻结测试判定（有 LLM，异步）。 */
+export function taskPerformanceRewardFn(llm: Llm): RewardFn {
+  return {
+    name: 'task-performance',
+    description: 'LLM 生成 + 冻结测试评 skill/通用任务',
+    evaluate: () => runTaskPerformance(llm),
+  }
+}
+
+/** 可枚举的奖励函数注册表。llm 缺省时只含无 LLM 的机制哨兵。 */
+export function listRewardFns(llm?: Llm): RewardFn[] {
+  return [mechanismSentinel(), ...(llm ? [taskPerformanceRewardFn(llm)] : [])]
+}

package/src/core/session-name.ts

@@ -0,0 +1,12 @@
+/**
+ * Generate the session name (ID) used for cross-session tracking, inbox routing,
+ * and session persistence.
+ *
+ * Includes milliseconds so two sessions launched in the same second do not
+ * collide on the shared inbox directory / active-session registry. (2026-08-27
+ * review: the old `slice(0, 19)` dropped ms and let same-second launches share
+ * one inbox, leaking / misdelivering cross-session messages.)
+ */
+export function generateSessionName(resume: string | undefined, now: Date = new Date()): string {
+  return resume || `session-${now.toISOString().replace(/[:.]/g, '-')}`
+}

package/src/core/task-performance-tasks.json

@@ -0,0 +1,42 @@
+{
+  "version": 1,
+  "tasks": [
+    {
+      "id": "perf-impl-quicksort",
+      "category": "test-driven",
+      "prompt": "实现并导出 quicksort 函数：export function quicksort(arr: number[]): number[]。只输出 TypeScript 代码，不要解释、不要 markdown 代码块。",
+      "testCode": "import { test, expect } from 'bun:test'\nimport { quicksort } from './solution'\n\ntest('sorts numbers', () => {\n  expect(quicksort([3, 1, 4, 1, 5, 9, 2, 6])).toEqual([1, 1, 2, 3, 4, 5, 6, 9])\n  expect(quicksort([])).toEqual([])\n  expect(quicksort([7])).toEqual([7])\n})\n"
+    },
+    {
+      "id": "perf-impl-fibonacci",
+      "category": "test-driven",
+      "prompt": "实现并导出 fibonacci 函数：export function fibonacci(n: number): number。返回第 n 项（fibonacci(0)=0, fibonacci(1)=1）。只输出 TypeScript 代码，不要解释、不要 markdown 代码块。",
+      "testCode": "import { test, expect } from 'bun:test'\nimport { fibonacci } from './solution'\n\ntest('computes fibonacci', () => {\n  expect(fibonacci(0)).toBe(0)\n  expect(fibonacci(1)).toBe(1)\n  expect(fibonacci(10)).toBe(55)\n  expect(fibonacci(20)).toBe(6765)\n})\n"
+    },
+    {
+      "id": "perf-impl-binary-search",
+      "category": "test-driven",
+      "prompt": "实现并导出 binarySearch 函数：export function binarySearch(arr: number[], target: number): number。返回 target 的下标，不存在返回 -1。假设 arr 已升序。只输出 TypeScript 代码，不要解释、不要 markdown 代码块。",
+      "testCode": "import { test, expect } from 'bun:test'\nimport { binarySearch } from './solution'\n\ntest('finds target', () => {\n  expect(binarySearch([1, 2, 3, 4, 5], 3)).toBe(2)\n  expect(binarySearch([1, 2, 3, 4, 5], 1)).toBe(0)\n  expect(binarySearch([1, 2, 3, 4, 5], 99)).toBe(-1)\n})\n"
+    },
+    {
+      "id": "perf-impl-reverse-string",
+      "category": "test-driven",
+      "prompt": "实现并导出 reverseString 函数：export function reverseString(s: string): string。只输出 TypeScript 代码，不要解释、不要 markdown 代码块。",
+      "testCode": "import { test, expect } from 'bun:test'\nimport { reverseString } from './solution'\n\ntest('reverses', () => {\n  expect(reverseString('hello')).toBe('olleh')\n  expect(reverseString('')).toBe('')\n  expect(reverseString('a')).toBe('a')\n})\n"
+    },
+    {
+      "id": "perf-impl-max",
+      "category": "test-driven",
+      "prompt": "实现并导出 maxOf 函数：export function maxOf(arr: number[]): number。返回数组最大值，空数组返回 -Infinity。只输出 TypeScript 代码，不要解释、不要 markdown 代码块。",
+      "testCode": "import { test, expect } from 'bun:test'\nimport { maxOf } from './solution'\n\ntest('finds max', () => {\n  expect(maxOf([1, 5, 3, 9, 2])).toBe(9)\n  expect(maxOf([-1, -5, -3])).toBe(-1)\n  expect(maxOf([])).toBe(-Infinity)\n})\n"
+    },
+    {
+      "id": "perf-safe-parse-positive",
+      "category": "test-driven",
+      "skill": "safe-coding",
+      "prompt": "实现并导出 parsePositiveNumber 函数：export function parsePositiveNumber(input: string): number。只输出 TypeScript 代码，不要解释、不要 markdown 代码块。",
+      "testCode": "import { test, expect } from 'bun:test'\nimport { parsePositiveNumber } from './solution'\n\ntest('rejects invalid input', () => {\n  expect(() => parsePositiveNumber(null as any)).toThrow(RangeError)\n  expect(() => parsePositiveNumber('')).toThrow(RangeError)\n  expect(() => parsePositiveNumber('abc')).toThrow(RangeError)\n})\ntest('parses valid', () => {\n  expect(parsePositiveNumber('42')).toBe(42)\n})\n"
+    }
+  ]
+}

package/src/core/task-performance.ts

@@ -0,0 +1,244 @@
+// apps/cli/src/core/task-performance.ts
+// CRSI 任务表现评估器：LLM 生成代码 + 冻结测试判定，输出随改动变化的分数。
+import { execSync } from 'node:child_process'
+import { mkdtempSync, writeFileSync, rmSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import tasksFile from './task-performance-tasks.json' with { type: 'json' }
+import type { Llm } from '../providers/llm'
+import { parseFrontmatter } from '../skills/loader'
+
+export type PerformanceTaskCategory = 'test-driven' | 'bug-fix'
+
+export interface PerformanceTask {
+  id: string
+  category: PerformanceTaskCategory
+  prompt: string
+  testCode: string
+  skill?: string // 绑定被测 skill 的名字（= skill frontmatter name）
+}
+
+export function loadPerformanceTasks(): PerformanceTask[] {
+  return tasksFile.tasks as PerformanceTask[]
+}
+
+export interface JudgeResult {
+  passed: boolean
+  detail?: string
+}
+
+const DEFAULT_TIMEOUT_MS = 5000
+
+/** 把生成代码 + 冻结测试写入临时目录，子进程跑 `bun test`，exit 0 即 pass。 */
+export function judgeGeneratedCode(
+  testCode: string,
+  solutionCode: string,
+  opts?: { timeoutMs?: number },
+): JudgeResult {
+  const dir = mkdtempSync(join(tmpdir(), 'mipham-task-perf-'))
+  try {
+    writeFileSync(join(dir, 'solution.ts'), solutionCode)
+    writeFileSync(join(dir, 'solution.test.ts'), testCode)
+    try {
+      execSync('bun test solution.test.ts', {
+        cwd: dir,
+        timeout: opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        stdio: 'pipe',
+      })
+      return { passed: true }
+    } catch (e) {
+      const stderr = (e as { stderr?: Buffer }).stderr?.toString() ?? ''
+      return { passed: false, detail: stderr.slice(0, 300) }
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+export interface TaskPerformanceResult {
+  id: string
+  description: string
+  passed: boolean
+  detail?: string
+}
+
+export interface TaskPerformanceReport {
+  total: number
+  passed: number
+  score: number
+  results: TaskPerformanceResult[]
+  failures: string[]
+}
+
+/** 剥掉 LLM 可能包裹的 markdown 代码块（```ts ... ```），拿到裸代码。 */
+export function stripCodeFences(text: string): string {
+  const fenced = text.match(/```(?:ts|typescript|js|javascript)?\n([\s\S]*?)```/)
+  return (fenced?.[1] ?? text).trim()
+}
+
+async function collectGeneratedCode(
+  llm: Llm,
+  prompt: string,
+  systemPrompt?: string,
+): Promise<string> {
+  let text = ''
+  const req = {
+    model: '', // falsy → registry 回退到 active model
+    messages: [{ role: 'user' as const, content: prompt }],
+    temperature: 0, // 温度 0，近确定
+    ...(systemPrompt ? { systemPrompt } : {}),
+  }
+  for await (const chunk of llm.chat(req)) {
+    if (chunk.type === 'text' && chunk.content) text += chunk.content
+  }
+  return stripCodeFences(text)
+}
+
+export async function runTaskPerformance(
+  llm: Llm,
+  opts?: { timeoutMs?: number; skill?: { name: string; text: string } },
+): Promise<TaskPerformanceReport> {
+  const wanted = opts?.skill?.name
+  const tasks = loadPerformanceTasks().filter((t) => (t.skill ?? undefined) === wanted)
+  const results: TaskPerformanceResult[] = []
+  for (const task of tasks) {
+    const code = await collectGeneratedCode(llm, task.prompt, opts?.skill?.text)
+    if (!code) {
+      results.push({
+        id: task.id,
+        description: task.prompt,
+        passed: false,
+        detail: 'LLM 未生成代码',
+      })
+      continue
+    }
+    const verdict = judgeGeneratedCode(task.testCode, code, opts)
+    results.push({
+      id: task.id,
+      description: task.prompt,
+      passed: verdict.passed,
+      detail: verdict.detail,
+    })
+  }
+  const passed = results.filter((r) => r.passed).length
+  return {
+    total: results.length,
+    passed,
+    score: results.length > 0 ? Math.round((passed / results.length) * 100) : 100,
+    results,
+    failures: results.filter((r) => !r.passed).map((r) => r.id),
+  }
+}
+
+export interface SkillDelta {
+  skillName: string
+  baseline: TaskPerformanceReport
+  post: TaskPerformanceReport
+  delta: number
+}
+
+interface ResolvedSkillProposal {
+  skillName: string
+  baselineText: string
+  postText: string
+}
+
+/** 路径门：只认内置 skill 文件。 */
+function isSkillFile(filePath: string): boolean {
+  return (
+    filePath.startsWith('apps/cli/skills/') &&
+    (filePath.endsWith('.SKILL.md') || filePath.endsWith('.mipham-skill.md'))
+  )
+}
+
+/** 解析改 skill 的 proposal → 名字 + 旧/新 body；非 skill / 无任务集 / 旧不可读 → null。 */
+function resolveSkillProposal(proposal: {
+  filePath: string
+  originalContent?: string
+  newContent: string
+}): ResolvedSkillProposal | null {
+  if (!isSkillFile(proposal.filePath)) return null
+
+  const newParsed = parseFrontmatter(proposal.newContent)
+  const skillName = typeof newParsed.data.name === 'string' ? newParsed.data.name : undefined
+  if (!skillName) return null
+
+  if (!loadPerformanceTasks().some((t) => t.skill === skillName)) return null
+
+  let baselineText: string
+  if (proposal.originalContent !== undefined) {
+    baselineText = parseFrontmatter(proposal.originalContent).content
+  } else {
+    try {
+      baselineText = parseFrontmatter(readFileSync(proposal.filePath, 'utf-8')).content
+    } catch {
+      return null // 旧 skill 不可读 → 无可量
+    }
+  }
+
+  return { skillName, baselineText, postText: newParsed.content }
+}
+
+/**
+ * 测一个改 skill 的 proposal 的任务表现 before/after delta。
+ * 返回 null：不是 skill 文件 / 无匹配任务集（无可量）。
+ * A1 不破：只调 runTaskPerformance（LLM 生成 + 冻结测试判定）。
+ */
+export async function measureSkillDelta(
+  llm: Llm,
+  proposal: { filePath: string; originalContent?: string; newContent: string },
+): Promise<SkillDelta | null> {
+  const resolved = resolveSkillProposal(proposal)
+  if (!resolved) return null
+
+  const baseline = await runTaskPerformance(llm, {
+    skill: { name: resolved.skillName, text: resolved.baselineText },
+  })
+  const post = await runTaskPerformance(llm, {
+    skill: { name: resolved.skillName, text: resolved.postText },
+  })
+
+  return {
+    skillName: resolved.skillName,
+    baseline,
+    post,
+    delta: post.score - baseline.score,
+  }
+}
+
+export interface SkillDeltaSample {
+  skillName: string
+  baselineScores: number[]
+  postScores: number[]
+}
+
+/**
+ * 多次采样 before/after（每次都是「LLM 生成 → 冻结测试判定」），供改进轨估噪声。
+ * 返回 null 门与 measureSkillDelta 相同。k 默认 3。
+ */
+export async function measureSkillDeltaRepeated(
+  llm: Llm,
+  proposal: { filePath: string; originalContent?: string; newContent: string },
+  opts?: { k?: number },
+): Promise<SkillDeltaSample | null> {
+  const resolved = resolveSkillProposal(proposal)
+  if (!resolved) return null
+
+  const k = opts?.k ?? 3
+  const baselineScores: number[] = []
+  const postScores: number[] = []
+  for (let i = 0; i < k; i++) {
+    const r = await runTaskPerformance(llm, {
+      skill: { name: resolved.skillName, text: resolved.baselineText },
+    })
+    baselineScores.push(r.score)
+  }
+  for (let i = 0; i < k; i++) {
+    const r = await runTaskPerformance(llm, {
+      skill: { name: resolved.skillName, text: resolved.postText },
+    })
+    postScores.push(r.score)
+  }
+
+  return { skillName: resolved.skillName, baselineScores, postScores }
+}

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

@@ -845,7 +845,9 @@
       "esc_to_interrupt": "esc to interrupt",
       "shift_tab_cycle": "shift+tab",
       "left_for_agents": "ctrl+g agents to manage",
-      "mipham_modes": "Mipham"
+      "mipham_modes": "Mipham",
+      "update_available": "Update available · v{version}",
+      "update_installed_restart": "Update installed · Restart to apply"
     },
     "wizard": {
       "header_subtitle": " — Configuration Wizard",

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

@@ -845,7 +845,9 @@
       "esc_to_interrupt": "Esc 中断",
       "shift_tab_cycle": "Shift+Tab",
       "left_for_agents": "ctrl+g 管理代理",
-      "mipham_modes": "Mipham独有"
+      "mipham_modes": "Mipham独有",
+      "update_available": "有新版 · v{version}",
+      "update_installed_restart": "更新已安装 · 重启生效"
     },
     "wizard": {
       "header_subtitle": " — 配置向导",

package/src/index.tsx

@@ -25,6 +25,7 @@ import { loadSessionMemories, getMemoryManager } from './core/memory/memory-load
 import { ContextManager } from './core/context'
 import { PrefixCacheTracker } from './core/context-token'
 import { QueryEngine } from './core/engine'
+import { generateSessionName } from './core/session-name'
 import { ExperienceRuleEngine } from './core/rule-engine.js'
 import { SessionLog } from './core/session-log'
 import { SessionStore } from './core/session-store'
@@ -40,6 +41,7 @@ import { mountConstitution, createConstitution } from './core/constitution-seam'
 import { ConstitutionLoader } from './core/constitution-loader'
 import { McpClient } from './mcp/client'
 import { registerMcpServerTools, syncMcpToolsOnChange } from './mcp/registry'
+import { formatMcpConnectFailures, type McpConnectFailure } from './mcp/connect-failures'
 import { AgentRegistry } from './agent/agent-registry'
 import { HookEngine } from './core/hooks'
 import { ArtifactServer } from './artifacts/server'
@@ -202,8 +204,8 @@ function SetupGate(props: SetupGateProps) {
 async function connectMcpServers(
   mcpServers: McpServerConfig[],
   tools: ReturnType<typeof createToolRegistry>,
-): Promise<void> {
-  if (mcpServers.length === 0) return
+): Promise<McpConnectFailure[]> {
+  if (mcpServers.length === 0) return []
   const mcp = McpClient.getInstance()
   // Wire runtime tool-list changes before connect so mid-connect updates land.
   syncMcpToolsOnChange(mcp, tools)
@@ -216,14 +218,17 @@ async function connectMcpServers(
       }
     }),
   )
+  const failures: McpConnectFailure[] = []
   for (let i = 0; i < results.length; i++) {
     const result = results[i]!
     if (result.status === 'rejected') {
-      process.stderr.write(
-        `[mcp] Failed to connect "${mcpServers[i]!.name}": ${String(result.reason)}\n`,
-      )
+      const name = mcpServers[i]!.name
+      const reason = String(result.reason)
+      failures.push({ name, reason })
+      process.stderr.write(`[mcp] Failed to connect "${name}": ${reason}\n`)
     }
   }
+  return failures
 }
 
 export async function runApp(options: RunOptions): Promise<void> {
@@ -325,8 +330,7 @@ export async function runApp(options: RunOptions): Promise<void> {
   const pluginManager = new PluginManager()
 
   // Generate session name for tracking (used by /cd to persist cwd)
-  const sessionName =
-    options.resume || `session-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`
+  const sessionName = generateSessionName(options.resume)
 
   // Initialize context — restore saved session if available
   // Read the active model's context window for dynamic max-token sizing.
@@ -498,7 +502,7 @@ export async function runApp(options: RunOptions): Promise<void> {
   // Connect MCP servers lazily in the background: the UI renders immediately,
   // and each server's tools register into the shared registry as it connects.
   // A dead server (e.g. a 15s connect timeout) no longer blocks startup.
-  void connectMcpServers(config.skills?.mcpServers ?? [], tools)
+  const mcpConnectPromise = connectMcpServers(config.skills?.mcpServers ?? [], tools)
 
   // Initialize hook engine — register skill-defined hooks
   const hookEngine = new HookEngine()
@@ -562,6 +566,14 @@ export async function runApp(options: RunOptions): Promise<void> {
 
   // ── Cross-session messaging: register session, heartbeat, shutdown ──
   engine.setSessionId(sessionName)
+
+  // Surface MCP connect failures to the model once they settle, so it knows
+  // those servers' tools are unavailable (rather than silently concluding the
+  // tools don't exist). Injected asynchronously — never blocks first paint.
+  void mcpConnectPromise.then((failures) => {
+    const notice = formatMcpConnectFailures(failures)
+    if (notice) engine.getContext().addMessage({ role: 'user', content: notice })
+  })
   // Human-readable, cross-session-addressable name. Defaults to the cwd basename
   // so `@mipham-code` can address this session; uniqueness is enforced against
   // other live sessions (suffix -2, -3, …). The id stays a stable `session-<ts>`.