@miphamai/cli 0.60.1 → 0.62.0

package/package.json

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

package/src/agent/effectiveness-tracker.ts

@@ -1,11 +1,14 @@
 import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 import type { CrsiProvenanceBridge, CrsiVerdict } from './crsi-provenance-bridge.js'
+import { isRecoverableToolFailure } from './recoverable-failure.js'
 
 export interface RuleEffectiveness {
   ruleId: string
   appliedCount: number
   successAfterCount: number
+  /** 可恢复/环境性失败数——记录但排除在成功率分母外。 */
+  recoverableCount?: number
   preRuleFailureRate: number
   postRuleFailureRate: number
   status: 'active' | 'degrading' | 'disabled'
@@ -44,7 +47,11 @@ export class EffectivenessTracker {
     if (eff) eff.decisionId = decisionId
   }
 
-  recordApplication(ruleId: string, success: boolean): void {
+  recordApplication(
+    ruleId: string,
+    success: boolean,
+    opts?: { toolName?: string; error?: string },
+  ): void {
     let eff = this.data.get(ruleId)
     if (!eff) {
       eff = {
@@ -61,6 +68,12 @@ export class EffectivenessTracker {
       this.data.set(ruleId, eff)
     }
 
+    // 可恢复/环境性失败：仍记录，但不进成功率分母（防误降级/误禁用能用的规则）。
+    if (!success && opts?.error && isRecoverableToolFailure(opts.toolName ?? '', opts.error)) {
+      eff.recoverableCount = (eff.recoverableCount ?? 0) + 1
+      return
+    }
+
     eff.appliedCount++
     if (success) eff.successAfterCount++
 

package/src/agent/recoverable-failure.ts

@@ -0,0 +1,21 @@
+/**
+ * 判「可恢复/环境性」失败 vs 真缺陷（borrow opencrabs `is_recoverable_tool_failure` 思想）。
+ *
+ * 可恢复失败（网络超时、连接拒绝、缺文件、环境权限）不该进成功率分母，否则会把成功率
+ * 拉低、诱导 EffectivenessTracker 禁用能用的规则（openprabs #236 的坑：stale-hash 重试
+ * 被误判成工具缺陷，把能用的 hashline_edit 禁了）。
+ *
+ * fail-closed：无 error、或非 Bash 工具，一律按真失败算（证不了可恢复就不排除）。
+ */
+const RECOVERABLE_PATTERNS: RegExp[] = [
+  /\btimed?\s?out\b/i, // timeout / timed out（网络慢 / 服务死）
+  /(ECONNREFUSED|connection refused|not connected|network unreachable)/i, // 服务未起
+  /(no such file or directory|ENOENT)/i, // 缺资源，非缺陷
+  /(permission denied|EACCES)/i, // 环境权限
+]
+
+export function isRecoverableToolFailure(toolName: string, error?: string): boolean {
+  if (!error || toolName !== 'Bash') return false
+  const e = error.toLowerCase()
+  return RECOVERABLE_PATTERNS.some((re) => re.test(e))
+}

package/src/core/cron-poller.ts

@@ -0,0 +1,52 @@
+// Cron poller — makes the CLI's durable CronCreate jobs actually fire.
+//
+// Every minute it reads ~/.mipham/cron/*.json and, for each job whose
+// nextFire has passed, enqueues the prompt into the engine's cron queue
+// (which re-invokes it into the current session) and then advances the job
+// (recurring → next fire; one-shot → deleted).
+
+import { computeNextFire } from './cron'
+import type { CronJob } from '../tools/scheduling/cron'
+import { readAllJobs, writeJob, deleteJobFile } from '../tools/scheduling/cron'
+
+/** Jobs whose nextFire is at or before `now`. Pure — separated for tests. */
+export function findDueJobs(jobs: CronJob[], now: Date): CronJob[] {
+  return jobs.filter((j) => new Date(j.nextFire).getTime() <= now.getTime())
+}
+
+/** Next state after firing a due job: recurring advances; one-shot → null (delete). */
+export function advanceJob(job: CronJob, now: Date): CronJob | null {
+  if (!job.recurring) return null
+  return {
+    ...job,
+    lastFired: now.toISOString(),
+    nextFire: computeNextFire(job.cron, now),
+  }
+}
+
+/** Read due jobs, enqueue their prompts, and advance/delete. Returns fired count. */
+export function checkCronJobs(enqueue: (prompt: string) => void, now = new Date()): number {
+  const due = findDueJobs(readAllJobs(), now)
+  for (const job of due) {
+    enqueue(job.prompt)
+    const next = advanceJob(job, now)
+    if (next) writeJob(next)
+    else deleteJobFile(job.id)
+  }
+  return due.length
+}
+
+/**
+ * Start the cron poller. Returns a stop function. The interval is unref'd so
+ * it never keeps the process alive on its own.
+ */
+export function startCronPoller(
+  enqueue: (prompt: string) => void,
+  intervalMs = 60_000,
+): () => void {
+  const timer = setInterval(() => {
+    checkCronJobs(enqueue)
+  }, intervalMs)
+  timer.unref()
+  return () => clearInterval(timer)
+}

package/src/core/cron.ts

@@ -0,0 +1,73 @@
+// Simple minute-granularity cron expression parser.
+//
+// Supports the standard 5-field cron format:
+//   minute hour day-of-month month day-of-week
+//
+// Handles: * (wildcard), star/N (step), N (exact), N-M (range), N,M,O (list).
+// Falls back to +1 minute if the expression is invalid or no match is found
+// within 366 days.
+
+export function computeNextFire(cronExpr: string, from: Date): string {
+  const fields = cronExpr.trim().split(/\s+/)
+  if (fields.length !== 5) {
+    return new Date(from.getTime() + 60_000).toISOString()
+  }
+
+  const minField = fields[0]!
+  const hourField = fields[1]!
+  const domField = fields[2]!
+  const monthField = fields[3]!
+  const dowField = fields[4]!
+
+  function matches(value: number, field: string): boolean {
+    if (field === '*') return true
+    // */N step
+    const stepMatch = field.match(/^\*\/(\d+)$/)
+    if (stepMatch) {
+      return value % parseInt(stepMatch[1]!, 10) === 0
+    }
+    // Comma-separated list
+    if (field.includes(',')) {
+      return field.split(',').some((f) => matches(value, f))
+    }
+    // Range
+    const rangeMatch = field.match(/^(\d+)-(\d+)$/)
+    if (rangeMatch) {
+      const low = parseInt(rangeMatch[1]!, 10)
+      const high = parseInt(rangeMatch[2]!, 10)
+      return value >= low && value <= high
+    }
+    // Exact value
+    return value === parseInt(field, 10)
+  }
+
+  const date = new Date(from)
+  date.setSeconds(0, 0)
+  // Start from the next minute to avoid matching the current minute
+  date.setMinutes(date.getMinutes() + 1)
+
+  // Try up to 366 days forward (safety limit — ~527k iterations)
+  const maxIterations = 366 * 24 * 60
+  for (let i = 0; i < maxIterations; i++) {
+    const minute = date.getMinutes()
+    const hour = date.getHours()
+    const dom = date.getDate()
+    const month = date.getMonth() + 1 // JS months are 0-indexed
+    const dow = date.getDay() // 0 = Sunday
+
+    if (
+      matches(minute, minField) &&
+      matches(hour, hourField) &&
+      matches(dom, domField) &&
+      matches(month, monthField) &&
+      matches(dow, dowField)
+    ) {
+      return date.toISOString()
+    }
+
+    date.setMinutes(date.getMinutes() + 1)
+  }
+
+  // Fallback: 1 minute from now
+  return new Date(from.getTime() + 60_000).toISOString()
+}

package/src/core/crsi-modify.ts

@@ -13,7 +13,7 @@
  */
 
 import { randomUUID } from 'node:crypto'
-import { CrsiSandbox } from './crsi-sandbox'
+import { CrsiSandbox, validateBlastRadius } from './crsi-sandbox'
 import type { CrsiModificationResult } from './crsi-sandbox'
 import { runEval, appendEvalScore, getLastEvalScore } from './eval-harness'
 
@@ -28,6 +28,13 @@ export interface CrsiProposal {
   originalContent?: string
   /** 触发此改动的 CRSI insight id */
   crsiInsightId?: string
+  /**
+   * 完整覆盖（blast radius）：此改动触及的**所有**代码路径（文件列表）。
+   *
+   * 源于 2026-08-26 教训：修「思考转储」只接实时指示器、漏历史行冲刷路径——
+   * 局部正确、全局遗漏。自修改前必须摸清并声明全部受影响路径，否则 fail-closed 拒绝。
+   */
+  blastRadius?: string[]
 }
 
 // ── Pending proposal registry (两阶段闸门) ──
@@ -42,6 +49,25 @@ export function runCrsiModification(
   proposal: CrsiProposal,
   sandbox: CrsiSandbox = new CrsiSandbox(),
 ): CrsiModificationResult {
+  // 完整覆盖闸：自修改必须声明 blastRadius，否则 fail-closed（在 worktree 之前，零副作用）。
+  const blastRadiusError = validateBlastRadius(proposal)
+  if (blastRadiusError) {
+    return {
+      modification: {
+        id: 'crsi-mod-rejected-blast-radius',
+        description: proposal.description,
+        filePath: proposal.filePath,
+        newContent: proposal.newContent,
+        originalContent: proposal.originalContent ?? '',
+        crsiInsightId: proposal.crsiInsightId,
+        timestamp: new Date().toISOString(),
+      },
+      applied: false,
+      phase: 'failed',
+      error: blastRadiusError,
+    }
+  }
+
   sandbox.createWorktree()
 
   const applied = sandbox.applyModification({

package/src/core/crsi-producer.ts

@@ -127,7 +127,13 @@ export function produceCrsiProposal(
   metaRules: MetaRule[],
   currentLessons: string,
   timestamp: string,
-): { description: string; filePath: string; newContent: string; originalContent: string } | null {
+): {
+  description: string
+  filePath: string
+  newContent: string
+  originalContent: string
+  blastRadius: string[]
+} | null {
   const signal = selectCrsiSignal(insights, metaRules)
   if (!signal) return null
 
@@ -142,6 +148,7 @@ export function produceCrsiProposal(
     filePath: LESSONS_FILE,
     newContent,
     originalContent: currentLessons,
+    blastRadius: [LESSONS_FILE],
   }
 }
 
@@ -215,7 +222,13 @@ export function renderManagedRuleSource(signal: CrsiSignal): string | null {
 export function produceRuleProposal(
   signal: CrsiSignal,
   currentManagedRules: string,
-): { description: string; filePath: string; newContent: string; originalContent: string } | null {
+): {
+  description: string
+  filePath: string
+  newContent: string
+  originalContent: string
+  blastRadius: string[]
+} | null {
   const ruleSource = renderManagedRuleSource(signal)
   if (!ruleSource) return null
 
@@ -232,6 +245,7 @@ export function produceRuleProposal(
     filePath: MANAGED_RULES_FILE,
     newContent,
     originalContent: currentManagedRules,
+    blastRadius: [MANAGED_RULES_FILE],
   }
 }
 

package/src/core/crsi-sandbox.ts

@@ -122,6 +122,24 @@ export function isProtectedPath(filePath: string): boolean {
   return PROTECTED_PATHS.some((p) => filePath === p || filePath.startsWith(p))
 }
 
+/**
+ * 完整覆盖闸（blast radius）：自修改 proposal 必须声明非空 blastRadius，否则拒绝。
+ *
+ * 源于 2026-08-26 教训：修「思考转储」只接实时指示器、漏历史行冲刷路径——
+ * 局部正确、全局遗漏。自修改前必须摸清并声明全部受影响路径，fail-closed。
+ *
+ * 返回错误字符串（拒绝理由），合法时返回 null。
+ */
+export function validateBlastRadius(proposal: { blastRadius?: string[] }): string | null {
+  if (!proposal.blastRadius || proposal.blastRadius.length === 0) {
+    return (
+      'blast radius 未声明：自修改必须枚举触及的全部代码路径。' +
+      '教训：两条渲染路径只接一条 = 局部正确全局遗漏。'
+    )
+  }
+  return null
+}
+
 // ── Sandbox ──
 
 export class CrsiSandbox {

package/src/core/engine.ts

@@ -105,6 +105,9 @@ export class QueryEngine {
   /** Pending /loop re-invocation prompts, enqueued by the ScheduleWakeup timer. */
   private wakeupQueue: Array<{ prompt: string; noop: boolean }> = []
 
+  /** Pending durable cron prompts, enqueued by the cron poller (FIFO — every due job fires). */
+  private cronQueue: string[] = []
+
   /** Callback fired whenever a wakeup is enqueued (the ScheduleWakeup timer fired). */
   private onWakeupEnqueued: (() => void) | null = null
 
@@ -148,6 +151,26 @@ export class QueryEngine {
     return this.wakeupQueue.length > 0
   }
 
+  /** Enqueue a durable cron prompt for re-invocation (FIFO — every due job fires). */
+  enqueueCronPrompt(prompt: string): void {
+    // Dedup by prompt: a recurring job whose previous fire is still queued
+    // (slow turn) re-fires the same prompt — skip it rather than pile up.
+    if (!this.cronQueue.includes(prompt)) {
+      this.cronQueue.push(prompt)
+    }
+    this.onWakeupEnqueued?.()
+  }
+
+  /** Pop the next pending cron prompt, or null when the queue is empty. */
+  dequeueCronPrompt(): string | null {
+    return this.cronQueue.shift() ?? null
+  }
+
+  /** Whether a cron prompt is pending re-invocation. */
+  hasPendingCron(): boolean {
+    return this.cronQueue.length > 0
+  }
+
   /** Session identifier for cross-session messaging. Set by the app startup via setSessionId(). */
   private sessionId: string = 'session-1'
 
@@ -1180,7 +1203,10 @@ export class QueryEngine {
           const match = warning.match(/^\[rule:([^\]]+)\]/)
           const ruleId = match?.[1]
           if (ruleId) {
-            tracker.recordApplication(ruleId, result.success)
+            tracker.recordApplication(ruleId, result.success, {
+              toolName: name,
+              error: result.error,
+            })
           }
         }
         tracker.persist()

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 } from './crsi-sandbox'
+import { isProtectedPath, validateBlastRadius } from './crsi-sandbox'
 import { produceRuleProposal, MANAGED_RULES_FILE } from './crsi-producer'
 import type { CrsiSignal } from './crsi-producer'
 import { loadBehaviorTasks, judgeBehaviorTask } from './behavior-tasks'
@@ -167,6 +167,16 @@ export function runEval(): EvalReport {
     results.push({ id, description: `受保护路径被拒: ${path}`, passed: isProtectedPath(path) })
   }
 
+  // ── 完整覆盖闸（ground truth：未声明 blast radius 的 proposal 被 fail-closed 拒绝） ──
+  results.push({
+    id: 'blast-radius-gate',
+    description: '自修改 proposal 未声明 blast radius 被拒，声明后放行',
+    passed:
+      validateBlastRadius({ blastRadius: undefined }) !== null &&
+      validateBlastRadius({ blastRadius: [] }) !== null &&
+      validateBlastRadius({ blastRadius: ['apps/cli/src/foo.ts'] }) === null,
+  })
+
   // ── 安全（ground truth：16 攻击零漏过） ──
   const redTeam = new RedTeam().run(constitution, preflight, errorDB)
   results.push({

package/src/core/instructions.ts

@@ -1,5 +1,5 @@
 import { readFileSync, existsSync } from 'node:fs'
-import { join } from 'node:path'
+import { join, resolve, relative, sep, isAbsolute } from 'node:path'
 import { execSync } from 'node:child_process'
 import { parse as parseYaml } from 'yaml'
 import type { InstructionFile } from '../shared/index.ts'
@@ -59,32 +59,78 @@ export function parsePromptExclude(value: unknown): string[] {
   return []
 }
 
+/** 定位仓库根（git rev-parse --show-toplevel），非 git 目录回退 cwd。 */
+export function gitRoot(cwd: string): string {
+  try {
+    return execSync('git rev-parse --show-toplevel', {
+      cwd,
+      timeout: 5000,
+      encoding: 'utf-8',
+    }).trim()
+  } catch {
+    return cwd
+  }
+}
+
+/** 从仓库根到 cwd 的目录链（含两端），就近（cwd）在最后。cwd 不在 root 下时退化为 [cwd]。 */
+export function discoverDirectories(root: string, cwd: string): string[] {
+  const absRoot = resolve(root)
+  const absCwd = resolve(cwd)
+  if (absCwd === absRoot) return [absRoot]
+
+  const rel = relative(absRoot, absCwd)
+  if (rel.startsWith('..') || isAbsolute(rel)) return [absCwd]
+
+  const dirs = [absRoot]
+  let cur = absRoot
+  for (const seg of rel.split(sep)) {
+    cur = join(cur, seg)
+    dirs.push(cur)
+  }
+  return dirs
+}
+
+/**
+ * 每目录内指令文件的读取顺序（后加载 = 更高优先级）。
+ * AGENTS.md（行业标准基线）→ AGENTS.override.md（Codex 覆盖层）→
+ * MIPHAM.md（Mipham 品牌）→ CLAUDE.md（Claude Code 兼容）。
+ * MIPHAM→CLAUDE 相对顺序保持现状不变，仅前置 AGENTS 两条，避免行为回归。
+ */
+export const INSTRUCTION_FILENAMES = [
+  'AGENTS.md',
+  'AGENTS.override.md',
+  'MIPHAM.md',
+  'CLAUDE.md',
+] as const
+
 export class InstructionsLoader {
   private instructions: InstructionFile[] = []
   private crsiLessonSummaries: CrsiLessonSummary[] = []
 
   loadAll(cwd: string): void {
     this.instructions = []
+    const root = gitRoot(cwd)
+
+    // Tier 1: 集团/公司策略（锚定仓库根，从任意子目录启动都正确；不读 AGENTS.md）
+    this.tryLoad(join(root, '..', '..', 'CLAUDE.md'), 'group') // Rismed_Ronxin_Capital
+    this.tryLoad(join(root, '..', 'CLAUDE.md'), 'company') // One_Mipham_Corporation
+    this.tryLoad(join(root, '..', 'MIPHAM.md'), 'group')
+
+    // Tier 2: 递归项目层 — git 根 → cwd，逐目录读，就近（cwd）最后 = 优先级最高
+    const dirs = discoverDirectories(root, cwd)
+    dirs.forEach((dir, i) => {
+      const level: InstructionFile['level'] = i === dirs.length - 1 ? 'project' : 'directory'
+      for (const name of INSTRUCTION_FILENAMES) {
+        this.tryLoad(join(dir, name), level)
+      }
+    })
 
-    // Tier 1: Ancestor-level CLAUDE.md (for Claude Code compatibility)
-    // ../../ = Rismed_Ronxin_Capital
-    this.tryLoad(join(cwd, '..', '..', 'CLAUDE.md'), 'group')
-    // ../ = One_Mipham_Corporation
-    this.tryLoad(join(cwd, '..', 'CLAUDE.md'), 'company')
-
-    // Tier 1b: Group-level MIPHAM.md — One_Mipham_Corporation is the root
-    this.tryLoad(join(cwd, '..', 'MIPHAM.md'), 'group')
-
-    // Tier 2: Project-level (CLAUDE.md + MIPHAM.md at cwd)
-    this.tryLoad(join(cwd, 'MIPHAM.md'), 'project')
-    this.tryLoad(join(cwd, 'CLAUDE.md'), 'project')
-
-    // Tier 3: User-level ~/.mipham/USER.md
+    // Tier 3: 用户层 ~/.mipham/USER.md
     const home = process.env.HOME || '~'
     this.tryLoad(join(home, '.mipham', 'USER.md'), 'user')
 
     // CRSI 教训召回：读 crsi-lessons.md 提取精华，注入系统提示（只写不读 → 写后召回）
-    this.crsiLessonSummaries = this.loadCrsiLessons(cwd)
+    this.crsiLessonSummaries = this.loadCrsiLessons(root)
   }
 
   buildSystemPrompt(permissionMode?: string): string {
@@ -235,17 +281,7 @@ Never omit it or present the work as purely human-authored.`)
   }
 
   /** 读 crsi-lessons.md（按仓库根定位）提取教训精华。读不到则返回空。 */
-  private loadCrsiLessons(cwd: string): CrsiLessonSummary[] {
-    let root = cwd
-    try {
-      root = execSync('git rev-parse --show-toplevel', {
-        cwd,
-        timeout: 5000,
-        encoding: 'utf-8',
-      }).trim()
-    } catch {
-      // 非 git 目录 → 回退 cwd
-    }
+  private loadCrsiLessons(root: string): CrsiLessonSummary[] {
     try {
       const content = readFileSync(join(root, LESSONS_FILE), 'utf-8')
       return extractCrsiLessonSummaries(content)
@@ -272,7 +308,7 @@ Never omit it or present the work as purely human-authored.`)
     const description = modeDescriptions[mode]
     if (!description) return ''
 
-    return `## Permission Context\n\n${description}\n\nWhen a tool is denied, do NOT retry with the same tool and similar parameters. Move on to a different approach or ask the user for guidance.`
+    return `## Permission Context\n\n${description}\n\nWhen a tool is denied, do NOT retry it or any other approval-gated tool — Bash, WebSearch, network, and Workflow are all blocked in this mode. If the task genuinely needs a blocked tool, STOP retrying and ask the user to switch to bypassPermissions (Shift+Tab) or add an allow rule (/permissions), then wait for the user's answer.`
   }
 
   list(): InstructionFile[] {

package/src/core/memory/memory-manager.ts

@@ -8,6 +8,7 @@ import {
   statSync,
 } from 'node:fs'
 import { join, extname } from 'node:path'
+import { similarities } from './tfidf'
 
 export interface MemoryMetadata {
   type: 'user' | 'feedback' | 'project' | 'reference'
@@ -113,21 +114,22 @@ export class MemoryManager {
 
   recall(context: string, limit: number = 10): MemoryEntry[] {
     const contextLower = context.toLowerCase()
+    const entries = [...this.memories.values()]
+    // TF-IDF cosine similarity (CJK-bigram aware) replaces the old word-overlap.
+    const sims = similarities(
+      context,
+      entries.map((e) => e.content),
+    )
     const scored: Array<{ entry: MemoryEntry; score: number }> = []
     const seen = new Set<string>()
 
-    for (const entry of this.memories.values()) {
-      let score = 0
-      // Match against relevance tags
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i]!
+      let score = sims[i]! * 10
+      // Match against relevance tags (strong curated signal)
       for (const tag of entry.metadata.relevance) {
         if (contextLower.includes(tag.toLowerCase())) score += 3
       }
-      // Match against content keywords
-      const contentWords = entry.content.toLowerCase().split(/\s+/)
-      const contextWords = new Set(contextLower.split(/\s+/))
-      for (const word of contentWords) {
-        if (contextWords.has(word) && word.length > 3) score += 1
-      }
       if (score > 0) {
         scored.push({ entry, score })
         seen.add(entry.name)

package/src/core/memory/tfidf.ts

@@ -0,0 +1,108 @@
+// Local TF-IDF similarity — zero-dependency "semantic-ish" recall.
+//
+// The built-in memory is local files and must stay offline. This module upgrades
+// the old exact-keyword overlap to TF-IDF-weighted cosine similarity, with a CJK
+// character-bigram tokenizer so Chinese content (which has no word separators)
+// is matched on adjacent-character overlap rather than whole-word equality.
+
+const CJK_RE = /[㐀-䶿一-鿿]/
+const WORD_RE = /[a-z0-9]/
+
+function isCjk(ch: string): boolean {
+  return CJK_RE.test(ch)
+}
+
+function isWordChar(ch: string): boolean {
+  return WORD_RE.test(ch)
+}
+
+/**
+ * Tokenize text into CJK character bigrams + lowercase ASCII words (length ≥ 2).
+ * Punctuation and single-char ASCII tokens are dropped as noise.
+ */
+export function tokenize(text: string): string[] {
+  const tokens: string[] = []
+  const lower = text.toLowerCase()
+  let i = 0
+
+  while (i < lower.length) {
+    const ch = lower[i]!
+    if (isCjk(ch)) {
+      let run = ''
+      while (i < lower.length && isCjk(lower[i]!)) {
+        run += lower[i]!
+        i++
+      }
+      if (run.length === 1) {
+        tokens.push(run)
+      } else {
+        for (let j = 0; j < run.length - 1; j++) {
+          tokens.push(run.slice(j, j + 2))
+        }
+      }
+    } else if (isWordChar(ch)) {
+      let word = ''
+      while (i < lower.length && isWordChar(lower[i]!)) {
+        word += lower[i]!
+        i++
+      }
+      if (word.length >= 2) tokens.push(word)
+    } else {
+      i++
+    }
+  }
+
+  return tokens
+}
+
+/** Cosine similarity between two sparse term-weight vectors. */
+export function cosine(a: Map<string, number>, b: Map<string, number>): number {
+  let dot = 0
+  let normA = 0
+  for (const [term, w] of a) {
+    normA += w * w
+    const wb = b.get(term)
+    if (wb !== undefined) dot += w * wb
+  }
+  let normB = 0
+  for (const w of b.values()) normB += w * w
+  if (normA === 0 || normB === 0) return 0
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB))
+}
+
+/** TF-IDF weight vector for one token list, given corpus document frequency. */
+function tfidfVector(
+  tokens: string[],
+  df: Map<string, number>,
+  numDocs: number,
+): Map<string, number> {
+  const tf = new Map<string, number>()
+  for (const t of tokens) tf.set(t, (tf.get(t) ?? 0) + 1)
+
+  const vec = new Map<string, number>()
+  for (const [term, freq] of tf) {
+    const idf = Math.log((numDocs + 1) / ((df.get(term) ?? 0) + 1)) + 1
+    vec.set(term, freq * idf)
+  }
+  return vec
+}
+
+/**
+ * Cosine similarity of a query against each document, index-aligned.
+ * `docs` are raw texts; tokenization + TF-IDF weighting is applied internally.
+ */
+export function similarities(query: string, docs: string[]): number[] {
+  const docTokens = docs.map(tokenize)
+  const queryTokens = tokenize(query)
+  const numDocs = docs.length
+
+  const df = new Map<string, number>()
+  for (const tokens of docTokens) {
+    for (const term of new Set(tokens)) {
+      df.set(term, (df.get(term) ?? 0) + 1)
+    }
+  }
+
+  const queryVec = tfidfVector(queryTokens, df, numDocs)
+  return docTokens.map((tokens) => cosine(queryVec, tfidfVector(tokens, df, numDocs)))
+}

package/src/daemon/schedule-manager.ts

@@ -6,79 +6,7 @@ import type { DaemonDatabase } from './database'
 import type { WorkerPool } from './worker-pool'
 import type { DaemonSchedule } from './types'
 import { logger } from './logger'
-
-// Simple minute-granularity cron expression parser.
-//
-// Supports the standard 5-field cron format:
-//   minute hour day-of-month month day-of-week
-//
-// Handles: * (wildcard), star/N (step), N (exact), N-M (range), N,M,O (list).
-// Falls back to +1 minute if the expression is invalid or no match is found
-// within 366 days.
-function computeNextFire(cronExpr: string, from: Date): string {
-  const fields = cronExpr.trim().split(/\s+/)
-  if (fields.length !== 5) {
-    return new Date(from.getTime() + 60_000).toISOString()
-  }
-
-  const minField = fields[0]!
-  const hourField = fields[1]!
-  const domField = fields[2]!
-  const monthField = fields[3]!
-  const dowField = fields[4]!
-
-  function matches(value: number, field: string): boolean {
-    if (field === '*') return true
-    // */N step
-    const stepMatch = field.match(/^\*\/(\d+)$/)
-    if (stepMatch) {
-      return value % parseInt(stepMatch[1]!, 10) === 0
-    }
-    // Comma-separated list
-    if (field.includes(',')) {
-      return field.split(',').some((f) => matches(value, f))
-    }
-    // Range
-    const rangeMatch = field.match(/^(\d+)-(\d+)$/)
-    if (rangeMatch) {
-      const low = parseInt(rangeMatch[1]!, 10)
-      const high = parseInt(rangeMatch[2]!, 10)
-      return value >= low && value <= high
-    }
-    // Exact value
-    return value === parseInt(field, 10)
-  }
-
-  const date = new Date(from)
-  date.setSeconds(0, 0)
-  // Start from the next minute to avoid matching the current minute
-  date.setMinutes(date.getMinutes() + 1)
-
-  // Try up to 366 days forward (safety limit — ~527k iterations)
-  const maxIterations = 366 * 24 * 60
-  for (let i = 0; i < maxIterations; i++) {
-    const minute = date.getMinutes()
-    const hour = date.getHours()
-    const dom = date.getDate()
-    const month = date.getMonth() + 1 // JS months are 0-indexed
-    const dow = date.getDay() // 0 = Sunday
-
-    if (
-      matches(minute, minField) &&
-      matches(hour, hourField) &&
-      matches(dom, domField) &&
-      matches(month, monthField) &&
-      matches(dow, dowField)
-    ) {
-      return date.toISOString()
-    }
-
-    date.setMinutes(date.getMinutes() + 1)
-  }
-
-  // Fallback: 1 minute from now
-  return new Date(from.getTime() + 60_000).toISOString()
-}
+import { computeNextFire } from '../core/cron'
 
 export class ScheduleManager {
   private db: DaemonDatabase

package/src/shared/package-info.ts

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

package/src/tools/scheduling/cron.ts

@@ -10,6 +10,7 @@ import { join } from 'node:path'
 import { createHash } from 'node:crypto'
 import { homedir } from 'node:os'
 import type { ToolDefinition } from '../../shared/index.ts'
+import { computeNextFire } from '../../core/cron'
 
 const CRON_DIR = join(homedir(), '.mipham', 'cron')
 
@@ -17,12 +18,14 @@ function ensureCronDir(): void {
   if (!existsSync(CRON_DIR)) mkdirSync(CRON_DIR, { recursive: true })
 }
 
-interface CronJob {
+export interface CronJob {
   id: string
   cron: string
   prompt: string
   recurring: boolean
   createdAt: string
+  nextFire: string
+  lastFired: string | null
 }
 
 function jobPath(id: string): string {
@@ -33,13 +36,21 @@ function generateId(cron: string, prompt: string): string {
   return createHash('sha256').update(`${cron}:${prompt}`).digest('hex').slice(0, 12)
 }
 
-function readAllJobs(): CronJob[] {
+/**
+ * Read all durable cron jobs. Backfills `nextFire`/`lastFired` for files
+ * written before the executor landed (they only had id/cron/prompt/recurring).
+ */
+export function readAllJobs(): CronJob[] {
   ensureCronDir()
   const jobs: CronJob[] = []
   for (const file of readdirSync(CRON_DIR)) {
     if (!file.endsWith('.json')) continue
     try {
-      jobs.push(JSON.parse(readFileSync(join(CRON_DIR, file), 'utf-8')))
+      const parsed = JSON.parse(readFileSync(join(CRON_DIR, file), 'utf-8')) as Partial<CronJob>
+      if (!parsed.nextFire)
+        parsed.nextFire = computeNextFire(parsed.cron ?? '* * * * *', new Date())
+      if (parsed.lastFired === undefined) parsed.lastFired = null
+      jobs.push(parsed as CronJob)
     } catch {
       /* skip corrupt files */
     }
@@ -47,6 +58,20 @@ function readAllJobs(): CronJob[] {
   return jobs.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
 }
 
+/** Persist a job (create or update) to its JSON file. */
+export function writeJob(job: CronJob): void {
+  ensureCronDir()
+  writeFileSync(jobPath(job.id), JSON.stringify(job, null, 2), 'utf-8')
+}
+
+/** Delete a job's file. Returns false when the job did not exist. */
+export function deleteJobFile(id: string): boolean {
+  const path = jobPath(id)
+  if (!existsSync(path)) return false
+  unlinkSync(path)
+  return true
+}
+
 export const cronCreateTool: ToolDefinition = {
   name: 'CronCreate',
   description:
@@ -82,17 +107,18 @@ export const cronCreateTool: ToolDefinition = {
     const recurring = params.recurring !== false
     const id = generateId(cron, prompt)
 
-    ensureCronDir()
-
+    const now = new Date()
     const job: CronJob = {
       id,
       cron,
       prompt: prompt.slice(0, 1000),
       recurring,
-      createdAt: new Date().toISOString(),
+      createdAt: now.toISOString(),
+      nextFire: computeNextFire(cron, now),
+      lastFired: null,
     }
 
-    writeFileSync(jobPath(id), JSON.stringify(job, null, 2), 'utf-8')
+    writeJob(job)
 
     const type = recurring ? 'recurring' : 'one-shot'
     return {
@@ -124,11 +150,9 @@ export const cronDeleteTool: ToolDefinition = {
   },
   async execute(params, _ctx) {
     const id = params.id as string
-    const path = jobPath(id)
-    if (!existsSync(path)) {
+    if (!deleteJobFile(id)) {
       return { success: false, content: '', error: `Cron job "${id}" not found.` }
     }
-    unlinkSync(path)
     return { success: true, content: `Cron job "${id}" deleted.` }
   },
 }

package/src/ui/app.tsx

@@ -52,6 +52,7 @@ import type { PermissionMode } from '../shared/index.ts'
 import { sanitizeForDisplay } from '../shared/sanitize.ts'
 import { recordLoopTurn, readAutoloopJournal } from '../commands/autoloop-journal.js'
 import { cancelAllSessionTimers } from '../tools/scheduling/schedule-wakeup.js'
+import { startCronPoller } from '../core/cron-poller'
 
 interface AppProps {
   engine: QueryEngine | RemoteEngine
@@ -686,9 +687,16 @@ export function App({
     // User turn wins: if a user submitted meanwhile, turnId advanced and this loop wakeup
     // yields (the next timer fire re-enqueues). Spec §六 — do not force it to run anyway.
     if (turnIdRef.current !== turnId) return
-    // RemoteEngine (remote attach mode) has no wakeup queue — /loop is CLI-local.
+    // RemoteEngine (remote attach mode) has no wakeup queue — /loop + cron are CLI-local.
     if (!('hasPendingWakeup' in engine)) return
-    const next = engine.hasPendingWakeup() ? engine.dequeueWakeup() : null
+    // Cron first (absolute-time scheduled, FIFO — every due job fires), then /loop.
+    const cronPrompt = engine.hasPendingCron() ? engine.dequeueCronPrompt() : null
+    const next =
+      cronPrompt !== null
+        ? { prompt: cronPrompt, noop: false }
+        : engine.hasPendingWakeup()
+          ? engine.dequeueWakeup()
+          : null
     if (next) await runTurn(next.prompt, 'loop', undefined, next.noop)
   }
 
@@ -713,6 +721,17 @@ export function App({
     drainLoopQueueRef.current?.(turnIdRef.current)
   }, [wakeupTick, isLoading])
 
+  // ── cron poller ──
+  // Start the durable-cron poller so CronCreate jobs actually fire into this session.
+  // It enqueues due prompts into the engine's cron queue; the drain above re-invokes
+  // them. Cron is CLI-local (RemoteEngine has no cron queue), like /loop.
+  useEffect(() => {
+    if (!('hasPendingWakeup' in engine)) return
+    const qe = engine // narrow to QueryEngine for the cleanup closure
+    const stop = startCronPoller((prompt) => qe.enqueueCronPrompt(prompt))
+    return stop
+  }, [engine])
+
   const handleSubmit = useCallback(
     async (input: string) => {
       if (!input.trim()) return