@miphamai/cli 0.85.4 → 0.85.6

package/bin/mipham.ts

@@ -293,13 +293,26 @@ async function runUpdate(): Promise<boolean> {
   if (!result.ok) {
     console.log()
     console.log(`✗ Update failed: ${result.reason ?? 'unknown error'}`)
-    if (result.rolledBack) {
-      console.log(
-        `  Your previous install (v${currentVersion}) has been restored — mipham still works.`,
-      )
-    } else {
-      console.log('  ⚠ The previous install could not be restored.')
-      console.log(`    Reinstall with: npm install -g ${PACKAGE}@${currentVersion}`)
+    // 这句必须只说**我们知道的**：staging 之后最常见的失败（装在旁边那步挂了）压根没碰过
+    // 旧树，此时沿用「未能恢复」就是在讲一件没发生的事。
+    switch (result.installState) {
+      case 'untouched':
+        console.log(
+          `  Your previous install (v${currentVersion}) was not touched — mipham still works.`,
+        )
+        break
+      case 'restored':
+        console.log(
+          `  Your previous install (v${currentVersion}) has been restored — mipham still works.`,
+        )
+        break
+      case 'unknown':
+        console.log('  ⚠ Could not locate the global install path — unable to tell.')
+        console.log(`    Check with: mipham --version`)
+        break
+      default:
+        console.log('  ⚠ The previous install could not be restored.')
+        console.log(`    Reinstall with: npm install -g ${PACKAGE}@${currentVersion}`)
     }
     if (backupPath && existsSync(backupPath)) {
       console.log(`  Your config backup is at: ${backupPath}`)
@@ -1249,6 +1262,8 @@ Flags:
   --resume <name>            Open a saved session (see /resume for names)
   --permission <mode>        Start in this mode: ${ALL_MODES.join('|')}
                              (also accepted by 'mipham attach'; the daemon may clamp it)
+  --provider <id>            Start on this provider (overrides config.yml)
+  --model <id>               Start on this model (overrides config.yml)
   --version, -v, -V          Print version
 
 Docs: https://mipham.ai/code
@@ -1384,12 +1399,38 @@ npm:  https://www.npmjs.com/package/@miphamai/cli`)
     process.exit(1)
   }
 
+  // Parse --provider <id> / --model <id>: the provider and model the session starts
+  // on. Same shape as `--resume`/`--permission` — `RunOptions` declared both fields all
+  // along, `index.tsx` already reads them *ahead of* the merged config, and **nothing
+  // ever passed them**. That third instance cost more than the first two: both shipped
+  // IDE integrations build this exact command from their settings
+  // (`infrastructure/vscode/extension.js` `buildFlags()`, `MiphamAction.kt`
+  // `buildCommand()`), so a user who set a provider there got
+  // `Unknown command: mipham deepseek` and no CLI at all. Their values are open — a
+  // provider may be user-defined — so the value is forwarded as typed and an unknown id
+  // is refused by the registry (`ProviderRegistry.getActive()` throws with the id named),
+  // exactly as the same value already was when it came from `config.yml`.
+  const flagValue = (name: string): string | undefined => {
+    const at = process.argv.indexOf(name)
+    if (at === -1) return undefined
+    const value = process.argv[at + 1]
+    if (!value || value.startsWith('-')) {
+      console.error(`Usage: mipham ${name} <id>`)
+      process.exit(1)
+    }
+    return value
+  }
+  const providerFlag = flagValue('--provider')
+  const modelFlag = flagValue('--model')
+
   try {
     const { runApp } = await import('../src/index')
     await runApp({
       version: APP_VERSION,
       resume: resumeName,
       permission: permissionFlag.kind === 'ok' ? permissionFlag.mode : undefined,
+      provider: providerFlag,
+      model: modelFlag,
     })
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.85.4",
+  "version": "0.85.6",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -40,7 +40,7 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "knip": "knip --production --no-progress --no-exit-code",
-    "coverage": "vitest run --coverage",
+    "coverage": "vitest run --coverage --reporter=default --reporter=json --outputFile.json=coverage/vitest-report.json",
     "mutate": "stryker run"
   },
   "dependencies": {

package/src/agent/agent-context.ts

@@ -13,6 +13,13 @@ import { MIPHAM_DIR } from '../shared/constants.ts'
 export interface AgentContextResult {
   context: ContextManager
   allowedTools: ToolDefinition[]
+  /**
+   * 组装好的系统提示（**含** agent memory）。
+   *
+   * 必须由这里交出去、而不是让调用方自己再拼一份：memory 的拼接规则只此一处，调用方
+   * 拿不到它就等于重新推导一遍（漏掉的那一遍正是缺陷本身 —— 请求里从来没有记忆）。
+   */
+  systemPrompt: string
 }
 
 /**
@@ -145,5 +152,5 @@ export function createAgentContext(
     allowedTools = allowedTools.filter((t) => !denySet.has(t.name))
   }
 
-  return { context, allowedTools }
+  return { context, allowedTools, systemPrompt }
 }

package/src/agent/effectiveness-tracker.ts

@@ -181,8 +181,22 @@ export class EffectivenessTracker {
   load(): void {
     if (!existsSync(this.storePath)) return
     try {
-      const raw = JSON.parse(readFileSync(this.storePath, 'utf-8'))
-      this.data = new Map(Object.entries(raw))
+      const parsed: unknown = JSON.parse(readFileSync(this.storePath, 'utf-8'))
+      // 形状门：要的是「**以规则 id 为键的对象**」。`Object.entries` 对数组会拿**下标**
+      // 当键（`{"0":"x"}` ⇒ 一条 ruleId 为 undefined 的记录），而 `new Map(...)` 照收，
+      // 于是 `allRules` 把非规则对象当规则报出去。
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        this.data = new Map()
+        return
+      }
+      const data = new Map<string, RuleEffectiveness>()
+      for (const [k, v] of Object.entries(parsed)) {
+        if (!v || typeof v !== 'object' || Array.isArray(v)) continue
+        const rec = v as { ruleId?: unknown }
+        if (typeof rec.ruleId !== 'string') continue
+        data.set(k, v as RuleEffectiveness)
+      }
+      this.data = data
     } catch {
       // Corrupt file — start fresh
       this.data = new Map()

package/src/agent/sub-agent.ts

@@ -339,23 +339,31 @@ export class SubAgent {
     }
 
     // Create isolated context with tool scoping, sized to the resolved model.
-    const resolvedDef: AgentDefinition = agentDef || {
-      name: agentType,
-      description: '',
-      systemPrompt,
-      model: options.modelOverride || 'inherit',
-      permissionMode: 'inherit',
-      background: false,
-      source: 'builtin',
-    }
+    // `systemPrompt` 是运行时**解析出来的那一份**（定义 > 调用方传入 > 内建类型），
+    // 定义自己没写时就落到解析结果上 —— 否则 `createAgentContext()` 拿到的是空串，
+    // 记忆会拼在一个空的基座上。
+    const resolvedDef: AgentDefinition = agentDef
+      ? { ...agentDef, systemPrompt: agentDef.systemPrompt || systemPrompt }
+      : {
+          name: agentType,
+          description: '',
+          systemPrompt,
+          model: options.modelOverride || 'inherit',
+          permissionMode: 'inherit',
+          background: false,
+          source: 'builtin',
+        }
     const contextWindow = this.registry.findModel(finalModel)?.contextWindow
-    const { context, allowedTools } = createAgentContext(
-      resolvedDef,
-      this.toolRegistry,
-      contextWindow,
-    )
+    // 这一份**已含 agent memory**，是发出去的那个提示的唯一来源。
+    const {
+      context,
+      allowedTools,
+      systemPrompt: composedSystemPrompt,
+    } = createAgentContext(resolvedDef, this.toolRegistry, contextWindow)
 
-    context.setSystemPrompt(systemPrompt)
+    // 别再 `context.setSystemPrompt(systemPrompt)`：`createAgentContext` 已经拿**含记忆**的
+    // 那一份设过上下文，这里用裸提示再设一遍只会把记忆从上下文里抹掉，而请求读的又不是
+    // 上下文 —— 两处各设一次的结果是「上下文里没有、请求里也没有」。
 
     // Seed inherited parent conversation (fork inheritance) as a byte-identical
     // prefix so the provider prompt cache is reused.
@@ -405,8 +413,8 @@ export class SubAgent {
     // 权限段随**唯一**带提示的那一轮走，而不是每轮派生。
     const permissionBlock = buildPermissionBlock(gate.getMode())
     let currentSystemPrompt = permissionBlock
-      ? `${systemPrompt}\n\n---\n\n${permissionBlock}`
-      : systemPrompt
+      ? `${composedSystemPrompt}\n\n---\n\n${permissionBlock}`
+      : composedSystemPrompt
     let totalTokens = 0
 
     // Context for the sub-agent's own tool calls. Built once per run: the caller's

package/src/agent-view/agents-standalone.tsx

@@ -0,0 +1,42 @@
+/**
+ * `mipham agents` 独立面板 —— 从 `index.tsx` 里抽出来的那段 JSX，好让它可测。
+ *
+ * 抽取的理由是**可测性**：`index.tsx` 是进程入口（`render` + `waitUntilExit`），
+ * 它里面传下去的东西在测试里够不着；而这条路上的 Enter 落点曾经整个缺席
+ * —— 页脚广告 attach，落点是 `() => {}`。
+ */
+
+import React, { useState } from 'react'
+
+import { AgentSessionView } from './session-view'
+import { AgentViewDashboard } from './dashboard'
+import type { AgentViewManager } from './agent-view-manager'
+
+interface AgentsStandaloneProps {
+  manager: AgentViewManager
+  onExit: () => void
+}
+
+export function AgentsStandalone({ manager, onExit }: AgentsStandaloneProps) {
+  // 与 `app.tsx` 同形：attach 把会话交给只读视图，视图里的 Esc 再交还列表。
+  // 页脚无条件印着「Enter attach」—— 它必须有个落点，否则按键有反应而世界不变。
+  const [attachedSessionId, setAttachedSessionId] = useState<string | null>(null)
+
+  if (attachedSessionId) {
+    return (
+      <AgentSessionView
+        manager={manager}
+        sessionId={attachedSessionId}
+        onDetach={() => setAttachedSessionId(null)}
+      />
+    )
+  }
+
+  return (
+    <AgentViewDashboard
+      manager={manager}
+      onAttach={(session) => setAttachedSessionId(session.id)}
+      onExit={onExit}
+    />
+  )
+}

package/src/core/autocomplete.ts

@@ -7,16 +7,39 @@ export const AUTOCOMPLETE_SYSTEM_PROMPT =
 /** 带上最近几条对话（含待续写输入），供续写贴合上下文。 */
 export const AUTOCOMPLETE_MAX_CONTEXT = 6
 
+/**
+ * 每条上下文消息最多带这么多**字符**（保留尾部）。
+ *
+ * 上面那个常数限的是**条数**，而一条 `content` 可以任意长 —— 贴进来一个文件、
+ * 或一条长回复，6 条就是上万 token，而用户每次 >400ms 的停顿都要买一次。
+ * 续写要看的是「刚说到哪儿」，所以砍头留尾；加 `…` 是免得把片段读成消息开头。
+ * 每条封顶 + 条数封顶，总量就是封死的，不需要再维护第二个预算常数。
+ */
+export const AUTOCOMPLETE_MAX_CHARS_PER_MESSAGE = 2000
+
 export interface RecentMessage {
   role: 'user' | 'assistant'
   content: string
 }
 
-/** 拼续写请求：systemPrompt + 最近 N 条 + 当前输入作为待续写消息。 */
+function tailOf(content: string): string {
+  return content.length <= AUTOCOMPLETE_MAX_CHARS_PER_MESSAGE
+    ? content
+    : '…' + content.slice(-AUTOCOMPLETE_MAX_CHARS_PER_MESSAGE)
+}
+
+/** 拼续写请求：systemPrompt + 最近 N 条（每条限长）+ 当前输入作为待续写消息。 */
 export function buildAutocompleteRequest(recent: RecentMessage[], input: string): ChatRequest {
   return {
     model: '', // falsy → registry 回退 active model
-    messages: [...recent.slice(-AUTOCOMPLETE_MAX_CONTEXT), { role: 'user', content: input }],
+    // 待续写的当前输入**不截断**：它是被续写的那条本身，且 extractCompletion 的
+    // 判据依赖它的完整值。上限落在历史消息上。
+    messages: [
+      ...recent
+        .slice(-AUTOCOMPLETE_MAX_CONTEXT)
+        .map((m) => ({ role: m.role, content: tailOf(m.content) })),
+      { role: 'user', content: input },
+    ],
     systemPrompt: AUTOCOMPLETE_SYSTEM_PROMPT,
     temperature: 0,
     maxTokens: 64,
@@ -57,6 +80,11 @@ export async function requestSuggestion(
   const req = buildAutocompleteRequest(recent, input)
   let text = ''
   for await (const chunk of llm.chat(req)) {
+    // 用户又敲了一下 ⇒ 这条请求已经过期，当场走人。`break` 不只是「不再读」：
+    // 它触发生成器的 `.return()` ⇒ provider 的 `finally` ⇒ `reader.cancel()`，
+    // 连接当场释放。若把这一判挪到循环外，就等于**先把整条流读完**再丢掉结果 ——
+    // 那正是「取消不掉」：每次 >400ms 的停顿都买一个完整 completion。
+    if (isStale()) break
     if (chunk.type === 'text' && chunk.content) text += chunk.content
   }
   if (isStale()) return null

package/src/core/context.ts

@@ -8,6 +8,7 @@ import {
   deriveMessages,
   assertModelVisible,
   isAssertModelVisibleDebug,
+  closeInterruptedToolCalls,
 } from './session-log'
 
 export type Summarizer = (messages: Message[], heading: string) => Promise<string>
@@ -45,6 +46,12 @@ export class ContextManager {
    * `index.tsx` 把它接到 live `PermissionSystem.getMode()` 上，于是切一次档，下一次请求就变。
    */
   private permissionContextSource: (() => string) | null = null
+  /**
+   * 系统提示里的 **MCP instructions 段**同样是读时派生的，理由比权限段更硬：
+   * MCP server 是**启动后异步连上**的，而提示在 `setSystemPrompt()` 那一刻就建好了。
+   * 组装时烘进去的话，本次会话里后连上的 server 永远进不了提示 —— 用户只能重启。
+   */
+  private mcpInstructionsSource: (() => string) | null = null
   private estimatedTokens = 0
   private checkpoints: Checkpoint[] = []
   private checkpointCounter = 0
@@ -79,6 +86,12 @@ export class ContextManager {
   /** 从已持久化的日志恢复：设 log 为源，messages 为投影（不重复写通）。 */
   restoreLog(log: SessionLog): void {
     this.log = log
+    // 盘上那份历史可能以一条**没有结果**的调用收尾（写盘写到一半被打断，末尾那行半截
+    // 结果被 `open()` 静默丢掉 —— 引擎自己的日志顺序到不了这个形状，见下面那个函数的
+    // 注释）。挂着 `tool_calls` 却没有结果回应的请求会被 provider 整条拒收，用户看到的
+    // 是「恢复之后第一句话就报协议错」。恢复的这一刻把它补**进日志**（不是补进投影，
+    // 否则「模型看得见的必须已记录」这条不变量当场破），见 `closeInterruptedToolCalls`。
+    closeInterruptedToolCalls(log)
     this.messages = deriveMessages(log.events())
     this.reEstimateTokens()
   }
@@ -124,7 +137,11 @@ export class ContextManager {
 
   setSystemPrompt(prompt: string): void {
     this.systemPrompt = prompt
-    this.estimatedTokens = this.estimateTokens(this.composedSystemPrompt())
+    // 估值必须**含 messages** —— 走 `reEstimateTokens()` 这一条唯一推导，别在这儿手写
+    // 第二份。`--resume` 路径（`index.tsx:584-585`）先 `restoreLog()` 算出含消息的完整
+    // 估值，紧接着调这里；只按系统提示重算会把它**覆盖成偏低值** ⇒ `needsCompaction()`
+    // 长期偏 false ⇒ 压缩迟触发（上下文越滚越大才动手）。
+    this.reEstimateTokens()
   }
 
   /**
@@ -138,14 +155,28 @@ export class ContextManager {
   }
 
   /**
-   * 存储的提示 + 读时派生的权限段。
+   * 接线点（`index.tsx`）：把已连 MCP server 自带的 `instructions` 接到提示上。
+   *
+   * 传 `null` 撤销。空串（无 server / 都没写 instructions）不产生空段。
+   */
+  setMcpInstructionsSource(fn: (() => string) | null): void {
+    this.mcpInstructionsSource = fn
+  }
+
+  /**
+   * 存储的提示 + 读时派生的段（权限 / MCP instructions）。
    *
-   * 段尾追加（而非插回原来的中段位置）是刻意的：只切档时**前缀保持不变**，
-   * 提供方的 prefix cache 仍能命中到权限段之前的部分。
+   * 段尾追加（而非插回原来的中段位置）是刻意的：只切档、只连一个新 server 时
+   * **前缀保持不变**，提供方的 prefix cache 仍能命中到这些段之前的部分。
    */
   private composedSystemPrompt(): string {
-    const block = this.permissionContextSource?.() ?? ''
-    return block ? `${this.systemPrompt}\n\n---\n\n${block}` : this.systemPrompt
+    const blocks = [
+      this.permissionContextSource?.() ?? '',
+      this.mcpInstructionsSource?.() ?? '',
+    ].filter((b) => b !== '')
+    return blocks.length > 0
+      ? [this.systemPrompt, ...blocks].join('\n\n---\n\n')
+      : this.systemPrompt
   }
 
   getSystemPrompt(): string {
@@ -170,6 +201,30 @@ export class ContextManager {
     this.checkCompression()
   }
 
+  /**
+   * 注入一段**模型可见的上下文**（规则块 / compact 前后的 hook 提示 / stop hook 交回的话 /
+   * 后台 agent 的来件）。
+   *
+   * 为什么不复用 addMessage：那会把注入记成 `user/message`，在日志里与**用户真说过的话**
+   * 完全同形 —— 事后翻 session log 分不出哪一句是用户敲的、哪一句是我们塞进去的。记成
+   * `context/inject`（带 `source`）就带得出来源；而 `deriveMessages` 仍把它还原成同一个
+   * user 消息，所以**投影逐字节不变**，「model-visible means logged」照样成立。
+   */
+  injectContext(source: string, text: string): void {
+    this.messages.push({ role: 'user', content: text })
+    this.estimatedTokens += this.estimateTokens(text)
+
+    if (this.log) {
+      this.log.append({ type: 'context/inject', at: Date.now(), source, text })
+    }
+
+    if (this.log && isAssertModelVisibleDebug()) {
+      assertModelVisible(this.log.events(), this.messages)
+    }
+
+    this.checkCompression()
+  }
+
   /** 记录工具执行结果（全量 ToolResult 含 success/error）到日志，并写投影消息（不重复走 messageToEvents 拆分）。 */
   addToolResult(toolUseId: string, result: ToolResult): void {
     const content = result.success ? result.content : result.error || result.content

package/src/core/dream-engine.ts

@@ -521,7 +521,11 @@ export class DreamEngine {
 
       let log: Array<{ timestamp: string; actions: DreamAction[] }> = []
       if (existsSync(this.dreamLog)) {
-        log = JSON.parse(readFileSync(this.dreamLog, 'utf-8'))
+        // 形状门：`{"a":1}` 是**合法 JSON**，不抛 —— 而 `log.unshift` 会抛，被下面的
+        // `catch` 吞掉 ⇒ 这一轮梦白做、且用户看不到任何提示。退成空表继续，
+        // 让这一轮活下来，别让它给一个坏文件陪葬。
+        const parsed: unknown = JSON.parse(readFileSync(this.dreamLog, 'utf-8'))
+        if (Array.isArray(parsed)) log = parsed
       }
       log.unshift({ timestamp, actions })
       // Keep last 10 dream cycles
@@ -536,7 +540,18 @@ export class DreamEngine {
   getDreamHistory(): Array<{ timestamp: string; actions: DreamAction[] }> {
     try {
       if (!existsSync(this.dreamLog)) return []
-      return JSON.parse(readFileSync(this.dreamLog, 'utf-8'))
+      const parsed: unknown = JSON.parse(readFileSync(this.dreamLog, 'utf-8'))
+      // 声明返回数组，就必须真的是数组：`{"a":1}` 合法且不抛，而调用方
+      // （`ui/commands.ts` 的 `/dream --status`）紧接着 `.length` / `.slice` /
+      // `entry.actions.length` ⇒ `try` 护不住调用点，TypeError 直接冒到 UI。
+      if (!Array.isArray(parsed)) return []
+      return parsed.filter(
+        (e): e is { timestamp: string; actions: DreamAction[] } =>
+          !!e &&
+          typeof e === 'object' &&
+          typeof e.timestamp === 'string' &&
+          Array.isArray(e.actions),
+      )
     } catch {
       return []
     }