dsh-omni-router 2.2.0 → 2.3.0

package/README.md

@@ -3,6 +3,10 @@
 > GitHub: https://github.com/qwe225380/dsh-omni-router
 > [中文说明](./README.zh-CN.md)
 
+> **Fast by default. Smart when needed. Proven when done.**
+> **Decide · Compose · Verify**
+> Install it. Keep coding.
+
 **Omni** 是一个 DeepSeek Harness 的 **reliability and orchestration control plane**，定位为 Intelligence Runtime：把复杂度路由、任务编译、项目上下文、能力编排、Mission DAG、Runtime 预算、证据验证、Memory/Learning、Benchmark 组合成一个统一的、自动运行的工程闭环。
 
 ## Why Omni Router?
@@ -74,6 +78,7 @@
 - **P1/P3 能力**：Real capability sandbox（已接入 `omni_mission_run`，按 role + capability 生成 toolFilter）、Capability Resolver v2（risk/reliability 综合打分）、OmniBench v2 runner（manifest schema + prepare + prompt generation + `--exec` 本地执行/结果采集 + DAG-to-plan compile）。
 - **2.1 收敛增强**：Mission Resume（`omni_mission_resume` 跨 session 继续 DAG，`runDagLoop` 支持 `onProgress` 周期保存）、Harness evidence extraction（`extractHarnessEvidence` 从 commands/tests/toolCalls/EVIDENCE_JSON 提取机器可验证证据）、context token budget（`maxContextTokens` 真正限制检索输出）、semantic failure retrieval + evidence-backed skill distillation、OmniBench v2 real runner。
 - **2.2 Capability Auto-Provisioning（优化7）**：Capability Auditor（baseline/task-time audit）、Gap Detection、Plugin/Skill Quality Scoring、Minimal Capability Set Solver、Discovery Adapters（marketplace/hub/static registry）、Trusted Auto Provisioning（recommend/auto-trusted/manual）、Post-install probe、Install rollback transaction、Capability performance learning / redundancy detection。
+- **2.3 Progressive Intelligence（优化8）**：L0 Direct / L1 Assisted / L2 Orchestrated / L3 Guarded 四级渐进智能；Context Capsule（最小相关上下文 + 动态 needs）；Strategy Shift（相同失败策略自动换策略，不再盲目 retry）；`omni_explain` / `omni_doctor` 用户入口。
 - **TaskDecision**：`createTaskDecision` 生成唯一决策对象，Policy/Runtime 统一消费，避免重复 classify 分叉。
 - **Evidence Protocol**：`src/evidence.mjs` 用结构化 command/file/test/finding 证据判定 PASS/FAIL；`isQaPass` 已支持从 QA 输出解析 JSON evidence，不再只信文本。
 - **Task Compiler**：`compileTask` 生成 objective / constraints / non-goals / acceptance / hidden assumptions / ambiguities / invariants / risk / artifacts；`compileTaskWithLLM` 可用 LLM 增强。
@@ -155,7 +160,7 @@ Then restart DSH and select **Omni Router** in a new session.
 - `/omni direct` — enter direct mode.
 - `/omni mode spec|react|balanced` — set thinking mode.
 - `/omni reroute plan|direct` — adaptively reroute current task.
-- Model tools: `omni_status`, `omni_plan`, `omni_direct`, `omni_mode`, `omni_reroute`, `omni_delegate`, `omni_memory`, `omni_benchmark`, `omni_mission_run`, `omni_mission_resume`, `omni_capability_audit`, `omni_capability_provision`, `omni_capability_probe`, `omni_visual_check`.
+- Model tools: `omni_status`, `omni_explain`, `omni_doctor`, `omni_plan`, `omni_direct`, `omni_mode`, `omni_reroute`, `omni_delegate`, `omni_memory`, `omni_benchmark`, `omni_mission_run`, `omni_mission_resume`, `omni_capability_audit`, `omni_capability_provision`, `omni_capability_probe`, `omni_capability_performance`, `omni_visual_check`.
 
 ## Configuration
 

package/README.zh-CN.md

@@ -3,6 +3,10 @@
 > GitHub：https://github.com/qwe225380/dsh-omni-router
 > [English](./README.md)
 
+> **默认快，必要时聪明，完成必须有证据。**
+> **Decide · Compose · Verify**
+> 安装即可使用，继续写代码。
+
 **Omni** 是一个 DeepSeek Harness 的 **reliability and orchestration control plane**，定位为 Intelligence Runtime：把复杂度路由、任务编译、项目上下文、能力编排、Mission DAG、Runtime 预算、证据验证、Memory/Learning、Benchmark 组合成一个统一的、自动运行的工程闭环。
 
 ## 为什么需要 Omni Router？
@@ -74,6 +78,7 @@
 - **P1/P3 能力**：Real capability sandbox（已接入 `omni_mission_run`，按 role + capability 生成 toolFilter）、Capability Resolver v2（risk/reliability 综合打分）、OmniBench v2 runner（manifest schema + prepare + prompt generation + `--exec` 本地执行/结果采集 + DAG-to-plan compile）。
 - **2.1 收敛增强**：Mission Resume（`omni_mission_resume` 跨 session 继续 DAG，`runDagLoop` 支持 `onProgress` 周期保存）、Harness evidence extraction（`extractHarnessEvidence` 从 commands/tests/toolCalls/EVIDENCE_JSON 提取机器可验证证据）、context token budget（`maxContextTokens` 真正限制检索输出）、semantic failure retrieval + evidence-backed skill distillation、OmniBench v2 real runner。
 - **2.2 Capability Auto-Provisioning（优化7）**：Capability Auditor（baseline/task-time audit）、Gap Detection、Plugin/Skill Quality Scoring、Minimal Capability Set Solver、Discovery Adapters（marketplace/hub/static registry）、Trusted Auto Provisioning（recommend/auto-trusted/manual）、Post-install probe、Install rollback transaction、Capability performance learning / redundancy detection。
+- **2.3 Progressive Intelligence（优化8）**：L0 Direct / L1 Assisted / L2 Orchestrated / L3 Guarded 四级渐进智能；Context Capsule（最小相关上下文 + 动态 needs）；Strategy Shift（相同失败策略自动换策略，不再盲目 retry）；`omni_explain` / `omni_doctor` 用户入口。
 - **TaskDecision**：`createTaskDecision` 生成唯一决策对象，Policy/Runtime 统一消费，避免重复 classify 分叉。
 - **Evidence Protocol**：`src/evidence.mjs` 用结构化 command/file/test/finding 证据判定 PASS/FAIL；`isQaPass` 已支持从 QA 输出解析 JSON evidence，不再只信文本。
 - **Task Compiler**：`compileTask` 生成 objective / constraints / non-goals / acceptance / hidden assumptions / ambiguities / invariants / risk / artifacts；`compileTaskWithLLM` 可用 LLM 增强。
@@ -155,7 +160,7 @@ node scripts/install-preset.mjs
 - `/omni direct` — 进入直接执行模式。
 - `/omni mode spec|react|balanced` — 设置思维模式。
 - `/omni reroute plan|direct` — 动态切换当前任务路由。
-- 模型工具：`omni_status` / `omni_plan` / `omni_direct` / `omni_mode` / `omni_reroute` / `omni_delegate` / `omni_memory` / `omni_benchmark` / `omni_mission_run` / `omni_mission_resume` / `omni_capability_audit` / `omni_capability_provision` / `omni_capability_probe` / `omni_visual_check`。
+- 模型工具：`omni_status` / `omni_explain` / `omni_doctor` / `omni_plan` / `omni_direct` / `omni_mode` / `omni_reroute` / `omni_delegate` / `omni_memory` / `omni_benchmark` / `omni_mission_run` / `omni_mission_resume` / `omni_capability_audit` / `omni_capability_provision` / `omni_capability_probe` / `omni_capability_performance` / `omni_visual_check`。
 
 ## 配置
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-omni-router",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Omni - a reliability and orchestration control plane for DeepSeek Harness, designed to turn fast models into dependable long-horizon software-engineering agents.",
   "type": "module",
   "main": "./lib/index.js",
@@ -41,7 +41,7 @@
     }
   },
   "scripts": {
-    "test": "node test/omni-router.test.mjs && node test/agent-chain.test.mjs && node test/skill-suggest.test.mjs && node test/methodology.test.mjs && node test/compat.test.mjs && node test/project-brain.test.mjs && node test/mission-planner.test.mjs && node test/agent-runtime.test.mjs && node test/judge.test.mjs && node test/memory.test.mjs && node test/memory-v3.test.mjs && node test/memory-engine.test.mjs && node test/mission-resume.test.mjs && node test/engineering-benchmark.test.mjs && node test/benchmark-runner.test.mjs && node test/benchmark-results.test.mjs && node test/continuous-eval.test.mjs && node --no-warnings test/project-brain-v2.test.mjs && node --no-warnings test/project-brain-v3.test.mjs && node test/visual-qa.test.mjs && node test/evidence.test.mjs && node test/evidence-store.test.mjs && node test/evidence-engine.test.mjs && node test/task-decision.test.mjs && node test/task-compiler.test.mjs && node test/capability-brain.test.mjs && node test/capability-manifest.test.mjs && node test/capability-sandbox.test.mjs && node test/capability-auditor.test.mjs && node test/capability-quality.test.mjs && node test/capability-solver.test.mjs && node test/capability-provisioner.test.mjs && node test/capability-performance.test.mjs && node test/planner-dag.test.mjs && node test/dynamic-context.test.mjs && node test/mission-dag.test.mjs && node test/failure-taxonomy.test.mjs && node test/context-expansion.test.mjs && node test/hybrid-retrieval.test.mjs && node test/dependency-graph.test.mjs && node test/ast-provider.test.mjs && node test/experience-router.test.mjs && node test/benchmark-tasks.test.mjs && node test/bundle-installer.test.mjs && node test/omnibench-runner.test.mjs",
+    "test": "node test/omni-router.test.mjs && node test/agent-chain.test.mjs && node test/skill-suggest.test.mjs && node test/methodology.test.mjs && node test/compat.test.mjs && node test/project-brain.test.mjs && node test/mission-planner.test.mjs && node test/agent-runtime.test.mjs && node test/judge.test.mjs && node test/memory.test.mjs && node test/memory-v3.test.mjs && node test/memory-engine.test.mjs && node test/mission-resume.test.mjs && node test/engineering-benchmark.test.mjs && node test/benchmark-runner.test.mjs && node test/benchmark-results.test.mjs && node test/continuous-eval.test.mjs && node --no-warnings test/project-brain-v2.test.mjs && node --no-warnings test/project-brain-v3.test.mjs && node test/visual-qa.test.mjs && node test/evidence.test.mjs && node test/evidence-store.test.mjs && node test/evidence-engine.test.mjs && node test/task-decision.test.mjs && node test/task-compiler.test.mjs && node test/capability-brain.test.mjs && node test/capability-manifest.test.mjs && node test/capability-sandbox.test.mjs && node test/capability-auditor.test.mjs && node test/capability-quality.test.mjs && node test/capability-solver.test.mjs && node test/capability-provisioner.test.mjs && node test/capability-performance.test.mjs && node test/progressive-intelligence.test.mjs && node test/context-capsule.test.mjs && node test/strategy-shift.test.mjs && node test/planner-dag.test.mjs && node test/dynamic-context.test.mjs && node test/mission-dag.test.mjs && node test/failure-taxonomy.test.mjs && node test/context-expansion.test.mjs && node test/hybrid-retrieval.test.mjs && node test/dependency-graph.test.mjs && node test/ast-provider.test.mjs && node test/experience-router.test.mjs && node test/benchmark-tasks.test.mjs && node test/bundle-installer.test.mjs && node test/omnibench-runner.test.mjs",
     "benchmark": "node benchmark/run.mjs",
     "benchmark:engineering": "node benchmark/engineering-run.mjs",
     "benchmark:compare": "node benchmark/compare.mjs",

package/src/agent-runtime.mjs

@@ -11,6 +11,7 @@
 
 import { buildPhaseTasks, decideReplan } from './mission-planner.mjs'
 import { applyObservationToDag, getReadyTasks, isMissionDagComplete, markTaskDone, selectReadyBatch } from './mission-dag.mjs'
+import { nextStrategy, shouldShiftStrategy } from './strategy-shift.mjs'
 
 export function createRuntimeState(mission, options = {}) {
   const phases = mission?.phases || []
@@ -187,6 +188,7 @@ export async function runDagLoop(dag, {
   let cost = 0
   let toolCalls = 0
   const actions = []
+  const failureHistory = new Map()
   const startTime = Date.now()
 
   const statusFromBudget = () => {
@@ -219,12 +221,21 @@ export async function runDagLoop(dag, {
       tokenUsage += Number(result?.tokenUsage || 0)
       cost += Number(result?.cost || 0)
       toolCalls += Number(result?.toolCalls || 0)
-      const isFailure = observation?.type === 'test_failure' || observation?.type === 'build_failure'
+      const isFailure = observation?.type === 'test_failure' || observation?.type === 'build_failure' || observation?.type === 'strategy_shift'
       if (isFailure) {
         replanCount += 1
         repairCount += 1
         sameActionCount = sameActionCount + 1
-        current = applyObservationToDag(current, { ...observation, taskId: task.id }, task.id)
+        const logicalKey = task.logicalId || task.id
+        const history = failureHistory.get(logicalKey) || []
+        history.push({ category: observation.type, reason: observation.reason, hypothesis: observation.hypothesis })
+        failureHistory.set(logicalKey, history)
+        let appliedObservation = { ...observation, taskId: task.id }
+        if (shouldShiftStrategy(history)) {
+          appliedObservation = { type: 'strategy_shift', reason: nextStrategy(history), taskId: task.id }
+          failureHistory.delete(logicalKey)
+        }
+        current = applyObservationToDag(current, appliedObservation, task.id)
       } else {
         sameActionCount = 0
         current = markTaskDone(current, task.id, observation)

package/src/capability-performance.mjs

@@ -6,12 +6,36 @@
  * demotion/removal decisions and benchmark plugin-contribution analysis.
  */
 
+import fs from 'node:fs'
+import path from 'node:path'
+
 export function createPerformanceRegistry(initial = {}) {
   return {
     providers: { ...(initial.providers || {}) },
   }
 }
 
+export function performanceRegistryPath(cwd) {
+  return path.join(cwd, '.omni', 'capability-performance.json')
+}
+
+export function loadPerformanceRegistry(cwd) {
+  const file = performanceRegistryPath(cwd)
+  if (!fs.existsSync(file)) return createPerformanceRegistry()
+  try {
+    return createPerformanceRegistry(JSON.parse(fs.readFileSync(file, 'utf8')))
+  } catch {
+    return createPerformanceRegistry()
+  }
+}
+
+export function savePerformanceRegistry(cwd, registry) {
+  const file = performanceRegistryPath(cwd)
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, JSON.stringify(registry, null, 2), 'utf8')
+  return file
+}
+
 export function recordProvisionOutcome(registry, providerId, outcome = {}) {
   const previous = registry.providers[providerId] || {
     runs: 0,

package/src/context-capsule.mjs

@@ -0,0 +1,113 @@
+/**
+ * Context Capsule.
+ *
+ * Gives a weak model the smallest useful slice of context for the current
+ * task: a few relevant files, their callers/callees, related tests, invariants,
+ * and recent failures. This is the opposite of dumping the whole repository
+ * map into the prompt.
+ */
+
+const STOP_WORDS = new Set([
+  'the', 'and', 'for', 'with', 'that', 'this', 'from', 'are', 'was', 'were',
+  'not', 'but', 'you', 'your', 'fix', 'add', 'make', 'use', 'should', 'when',
+])
+
+export function buildContextCapsule(taskText, options = {}) {
+  const entries = options.entries || []
+  const files = options.files || {}
+  const graph = options.graph || {}
+  const needs = options.needs || []
+  const invariants = options.invariants || []
+  const failures = options.failures || []
+  const maxFiles = Number(options.maxFiles) || 6
+  const maxTotalChars = Number(options.maxTotalChars) || 8000
+  const maxFileChars = Number(options.maxFileChars) || 1200
+
+  const keywords = extractKeywords([taskText, ...needs])
+  const fileNames = entries.filter((e) => e.type === 'file').map((e) => e.name)
+  const scored = fileNames.map((name) => {
+    const content = files[name] || ''
+    const nameScore = scoreText(name, keywords)
+    const contentScore = content ? scoreText(content.slice(0, 2000), keywords) * 0.5 : 0
+    return { name, score: nameScore + contentScore }
+  }).sort((a, b) => b.score - a.score)
+  const selected = scored.slice(0, maxFiles).map((s) => s.name)
+
+  const lines = []
+  lines.push(`Task: ${taskText}`)
+  if (needs.length) lines.push(`Needs: ${needs.join('; ')}`)
+  if (selected.length) {
+    lines.push('', 'Relevant files:')
+    for (const name of selected) {
+      const content = files[name] || ''
+      lines.push(`--- ${name} ---`)
+      lines.push(content ? content.slice(0, maxFileChars) : '(no content indexed)')
+    }
+  }
+
+  const edgeLines = []
+  for (const name of selected) {
+    for (const edge of graph[name] || []) {
+      edgeLines.push(`${name} ${edge.kind || '->'} ${edge.to || edge}`)
+    }
+  }
+  if (edgeLines.length) {
+    lines.push('', 'Callers / callees:')
+    lines.push(...edgeLines.slice(0, 20))
+  }
+
+  const tests = fileNames.filter((n) =>
+    /\.(test|spec)\./i.test(n) &&
+    (selected.includes(n) || keywords.some((k) => n.toLowerCase().includes(k))),
+  )
+  if (tests.length) {
+    lines.push('', 'Tests:')
+    lines.push(...tests.map((t) => `- ${t}`))
+  }
+
+  if (invariants.length) {
+    lines.push('', 'Invariants:')
+    lines.push(...invariants.map((i) => `- ${i}`))
+  }
+
+  if (failures.length) {
+    lines.push('', 'Recent failures:')
+    lines.push(...failures.map((f) => `- ${f}`))
+  }
+
+  let text = lines.join('\n')
+  if (text.length > maxTotalChars) {
+    text = `${text.slice(0, maxTotalChars)}\n… (context capsule truncated)`
+  }
+  return text
+}
+
+export function expandContextCapsule(current, request, options = {}) {
+  const requestText = Array.isArray(request) ? request.join('; ') : String(request || '')
+  if (!requestText) return current
+  const extra = buildContextCapsule(requestText, {
+    ...options,
+    maxFiles: Math.max(Number(options.maxFiles) || 6, 3),
+    maxTotalChars: Math.max(Number(options.maxTotalChars) || 8000, 4000),
+  })
+  return `${current}\n\n--- additional context requested ---\n${extra}`
+}
+
+function extractKeywords(texts = []) {
+  const words = new Set()
+  for (const text of texts) {
+    for (const match of String(text || '').toLowerCase().match(/[a-z0-9_]+/g) || []) {
+      if (match.length > 2 && !STOP_WORDS.has(match)) words.add(match)
+    }
+  }
+  return [...words]
+}
+
+function scoreText(text, keywords) {
+  const lower = String(text || '').toLowerCase()
+  let score = 0
+  for (const keyword of keywords) {
+    if (lower.includes(keyword)) score += 1
+  }
+  return score
+}

package/src/mission-dag.mjs

@@ -103,7 +103,7 @@ export function insertAfter(dag, afterId, task) {
 
 export function applyObservationToDag(dag, observation = {}, failedTaskId = null) {
   const type = observation.type || ''
-  if (type === 'test_failure' || type === 'build_failure') {
+  if (type === 'test_failure' || type === 'build_failure' || type === 'strategy_shift') {
     const taskId = failedTaskId || observation.taskId || null
     const failedTask = taskId ? dag.tasks.find((t) => t.id === taskId) : null
     const baseId = taskId || 'T'
@@ -114,13 +114,16 @@ export function applyObservationToDag(dag, observation = {}, failedTaskId = null
     const tasks = (dag.tasks || []).map((t) => t.id === taskId ? { ...t, status: 'failed', attempt, failure: observation } : t)
     const doneIds = tasks.filter((t) => t.status === 'done').map((t) => t.id)
     const failure = classifyFailure(observation)
+    const isShift = type === 'strategy_shift'
     const repair = createTask({
       id: repairId,
-      goal: `Diagnose and repair: ${failure.category} — ${failure.recovery}`,
+      goal: isShift
+        ? `Strategy shift: ${observation.reason || 're-investigate with broader context and fresh capabilities'}`
+        : `Diagnose and repair: ${failure.category} — ${failure.recovery}`,
       dependencies: doneIds,
-      acceptance: ['verification passes after repair'],
+      acceptance: ['root cause is re-diagnosed and verification passes'],
       verification: ['run failing checks again'],
-      requiredCapabilities: ['debugging'],
+      requiredCapabilities: isShift ? ['debugging', 'repository.search'] : ['debugging'],
       forbiddenCapabilities: ['source.write'],
     })
     // Repair tasks should be allowed to write; fix forbidden.

package/src/omni-router.mjs

@@ -37,6 +37,8 @@ import { loadCapabilityManifests } from './capability-manifest.mjs'
 import { capabilityToolFilter } from './capability-sandbox.mjs'
 import { baselineAudit, formatCapabilityAudit, taskTimeAudit } from './capability-auditor.mjs'
 import { createStaticRegistryAdapter, discoverCandidates, evaluateProvisionPlan, formatProvisionResult, probeCapability, provisionCapabilities } from './capability-provisioner.mjs'
+import { evaluateProviderValue, formatPerformanceRegistry, loadPerformanceRegistry, recommendDemotion, recordProvisionOutcome, savePerformanceRegistry } from './capability-performance.mjs'
+import { decideIntelligenceLevel, formatIntelligenceLevel } from './progressive-intelligence.mjs'
 import { buildProgressiveContext } from './context-expansion.mjs'
 import { buildDynamicContext } from './dynamic-context.mjs'
 import { classifyFailure } from './failure-taxonomy.mjs'
@@ -1010,11 +1012,20 @@ export function apply(ctx, config = {}) {
       const agent = agentFor(session)
       const state = states.get(session.id) || { kind: null, taskType: null, thinkingMode: null, riskLevel: null, firstText: null, planRequested: false, directOverride: false }
       const routerStandard = agent ? isRouterStandardAvailable(ctx.get('tools') || ctx.tools, agent) : false
+      const taskDecision = createTaskDecision({
+        taskText: state.firstText || '',
+        taskType: state.taskType || 'other',
+        complexity: state.kind === 'plan' ? 'plan' : state.kind === 'direct' ? 'direct' : 'balanced',
+        risk: state.riskLevel || 'low',
+        thinkingMode: state.thinkingMode || 'balanced',
+      })
+      const intelligence = decideIntelligenceLevel(taskDecision)
       return [
         `omni-router: ${state.kind || 'unclassified'}`,
         `taskType=${state.taskType || 'unknown'}`,
         `thinkingMode=${state.thinkingMode || 'balanced'}`,
         `riskLevel=${state.riskLevel || 'unknown'}`,
+        `intelligenceLevel=${formatIntelligenceLevel(intelligence)}`,
         `planRequested=${state.planRequested}`,
         `directOverride=${state.directOverride}`,
         `routerStandard=${routerStandard ? 'delegated' : 'not-detected'}`,
@@ -1022,6 +1033,69 @@ export function apply(ctx, config = {}) {
     },
   })
 
+  registerTool({
+    name: 'omni_explain',
+    description: 'Explain why Omni chose the current mode, capabilities, verification level, and what is needed for completion.',
+    parameters: {
+      type: 'object',
+      properties: {
+        topic: { type: 'string', description: 'Optional topic to focus on: mode, capabilities, verification, completion' },
+      },
+    },
+    execute(args) {
+      const session = currentSession()
+      if (!session) return 'no agent session'
+      const state = states.get(session.id) || {}
+      const decision = createTaskDecision({
+        taskText: state.firstText || '',
+        taskType: state.taskType || 'other',
+        complexity: state.kind === 'plan' ? 'plan' : state.kind === 'direct' ? 'direct' : 'balanced',
+        risk: state.riskLevel || 'low',
+        thinkingMode: state.thinkingMode || 'balanced',
+      })
+      const intelligence = decideIntelligenceLevel(decision)
+      const topic = String(args?.topic || '').toLowerCase()
+      const lines = [
+        `Mode: ${intelligence.level} ${intelligence.label}`,
+        `Why: complexity=${decision.complexity}, risk=${decision.risk}, taskType=${decision.type}`,
+        `Reasoning effort: ${intelligence.reasoningEffort}`,
+        `Verification: ${intelligence.verification}`,
+        `Approval required: ${intelligence.approvalRequired ? 'yes' : 'no'}`,
+        `Capabilities needed: ${(decision.evidenceRequirements || []).join(', ') || 'native tools'}`,
+        `Completion requires: ${decision.evidenceRequirements?.length ? 'harness evidence for ' + decision.evidenceRequirements.join(', ') : 'light verification'}`,
+      ]
+      if (topic === 'mode' || topic === 'capabilities' || topic === 'verification' || topic === 'completion') {
+        const idx = lines.findIndex((l) => l.toLowerCase().startsWith(topic))
+        return idx >= 0 ? lines[idx] : lines.join('\n')
+      }
+      return lines.join('\n')
+    },
+  })
+
+  registerTool({
+    name: 'omni_doctor',
+    description: 'Run a quick environment/capability/project-index health check.',
+    parameters: {},
+    async execute() {
+      const session = currentSession()
+      const toolsService = ctx.get('tools') || ctx.tools
+      const toolNames = await collectToolNames(toolsService)
+      let brain = autoPopulateCapabilityBrain(createCapabilityBrain(), toolNames)
+      brain = loadCapabilityManifests(brain, config.capabilityManifests || [])
+      const baseline = baselineAudit(brain)
+      const fs = ctx.get('fs') || ctx.fs
+      const lines = [
+        `DSH session: ${session ? 'ok' : 'missing'}`,
+        `Tools registered: ${toolNames.length}`,
+        `Baseline capability coverage: ${baseline.available.length}/${baseline.required.length}`,
+        `Missing baseline: ${baseline.missing.join(', ') || '(none)'}`,
+        `ProjectIndex: ${fs ? 'available' : 'unavailable'}`,
+        `Evidence hooks: ${ctx.get('evidence') || ctx.evidence ? 'available' : 'not-detected'}`,
+      ]
+      return lines.join('\n')
+    },
+  })
+
   registerTool({
     name: 'omni_memory',
     description: 'View or update Omni session memory. Actions: status, add (with type=project|decision|failure|trajectory and text), clear.',
@@ -1600,6 +1674,63 @@ export function apply(ctx, config = {}) {
     },
   })
 
+  registerTool({
+    name: 'omni_capability_performance',
+    description: 'Track and inspect whether provisioned plugins/skills measurably improve task success, false completion, tokens, or tool errors.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['list', 'record', 'recommend'], description: 'Action (default list)' },
+        provider: { type: 'string', description: 'Provider id' },
+        successBefore: { type: 'number', description: 'Task success before provisioning' },
+        successAfter: { type: 'number', description: 'Task success after provisioning' },
+        falseCompletionBefore: { type: 'number', description: 'False completion rate before' },
+        falseCompletionAfter: { type: 'number', description: 'False completion rate after' },
+        tokensBefore: { type: 'number', description: 'Token usage before' },
+        tokensAfter: { type: 'number', description: 'Token usage after' },
+        toolErrorsBefore: { type: 'number', description: 'Tool errors before' },
+        toolErrorsAfter: { type: 'number', description: 'Tool errors after' },
+        usageDays: { type: 'number', description: 'Days since last use (for recommend)' },
+        uniqueCapabilities: { type: 'number', description: 'Number of unique capabilities (for recommend)' },
+        coveredBy: { type: 'array', items: { type: 'string' }, description: 'Other providers covering the same capabilities (for recommend)' },
+      },
+      required: [],
+    },
+    async execute(args) {
+      const session = currentSession()
+      const cwd = session?.meta?.cwd || session?.header?.cwd
+      if (!cwd) return 'No workspace cwd found.'
+      const action = args?.action || 'list'
+      let registry = loadPerformanceRegistry(cwd)
+      if (action === 'record') {
+        if (!args?.provider) return 'provider is required for record.'
+        registry = recordProvisionOutcome(registry, args.provider, {
+          successBefore: args.successBefore,
+          successAfter: args.successAfter,
+          falseCompletionBefore: args.falseCompletionBefore,
+          falseCompletionAfter: args.falseCompletionAfter,
+          tokensBefore: args.tokensBefore,
+          tokensAfter: args.tokensAfter,
+          toolErrorsBefore: args.toolErrorsBefore,
+          toolErrorsAfter: args.toolErrorsAfter,
+        })
+        const file = savePerformanceRegistry(cwd, registry)
+        const value = evaluateProviderValue(registry.providers[args.provider])
+        return `Recorded ${args.provider}: ${value.label} (${value.value})\nSaved: ${file}`
+      }
+      if (action === 'recommend') {
+        if (!args?.provider) return 'provider is required for recommend.'
+        const rec = recommendDemotion(registry, args.provider, {
+          usageDays: Number(args.usageDays) || 0,
+          uniqueCapabilities: Number(args.uniqueCapabilities) || 0,
+          coveredBy: Array.isArray(args.coveredBy) ? args.coveredBy : [],
+        })
+        return `${rec.providerId}: ${rec.recommendation} — ${rec.reason}`
+      }
+      return formatPerformanceRegistry(registry)
+    },
+  })
+
   registerTool({
     name: 'omni_mission_run',
     description: 'Run a Mission Planner loop with real subagents: Observe → Think → Act → Replan until completed or maxSteps.',

package/src/progressive-intelligence.mjs

@@ -0,0 +1,85 @@
+/**
+ * Progressive Intelligence.
+ *
+ * Omni should be invisible for simple tasks and gradually unfold for hard
+ * ones. This module maps a TaskDecision to one of four run levels:
+ *
+ *   L0 Direct       — raw DSH + light verification
+ *   L1 Assisted     — context + skill + test
+ *   L2 Orchestrated — plan + DAG + subagents + evidence
+ *   L3 Guarded      — deep plan + approval + independent verify + rollback
+ */
+
+export const INTELLIGENCE_LEVELS = ['L0', 'L1', 'L2', 'L3']
+
+export function decideIntelligenceLevel(decision = {}) {
+  const complexity = decision.complexity || 'direct'
+  const risk = decision.risk || 'low'
+  const taskType = decision.type || decision.taskType || 'other'
+
+  if (risk === 'high' || risk === 'critical') {
+    return {
+      level: 'L3',
+      label: 'Guarded',
+      useDag: true,
+      useSubagents: true,
+      approvalRequired: true,
+      verification: 'full',
+      independentVerify: true,
+      reasoningEffort: 'max',
+      contextMaxFiles: 20,
+      maxTaskAdditions: 1,
+      description: 'High-risk task: deep plan, approval, independent verify, rollback.',
+    }
+  }
+
+  if (complexity === 'plan' || (['feature', 'refactor'].includes(taskType) && complexity !== 'direct')) {
+    return {
+      level: 'L2',
+      label: 'Orchestrated',
+      useDag: true,
+      useSubagents: true,
+      approvalRequired: false,
+      verification: 'full',
+      independentVerify: false,
+      reasoningEffort: 'high',
+      contextMaxFiles: 12,
+      maxTaskAdditions: 1,
+      description: 'Multi-file or complex task: DAG + subagents + evidence.',
+    }
+  }
+
+  if (complexity === 'balanced' || ['bugfix', 'test'].includes(taskType)) {
+    return {
+      level: 'L1',
+      label: 'Assisted',
+      useDag: false,
+      useSubagents: false,
+      approvalRequired: false,
+      verification: 'standard',
+      independentVerify: false,
+      reasoningEffort: 'balanced',
+      contextMaxFiles: 6,
+      maxTaskAdditions: 0,
+      description: 'Normal task: focused context + skills + tests.',
+    }
+  }
+
+  return {
+    level: 'L0',
+    label: 'Direct',
+    useDag: false,
+    useSubagents: false,
+    approvalRequired: false,
+    verification: 'light',
+    independentVerify: false,
+    reasoningEffort: 'balanced',
+    contextMaxFiles: 3,
+    maxTaskAdditions: 0,
+    description: 'Simple task: raw DSH + light verification.',
+  }
+}
+
+export function formatIntelligenceLevel(level = {}) {
+  return `${level.level} ${level.label} — ${level.description}`
+}

package/src/strategy-shift.mjs

@@ -0,0 +1,34 @@
+/**
+ * Strategy Shift.
+ *
+ * Prevents blind retry loops: when the same failure category/reason repeats,
+ * Omni stops issuing another identical repair and instead re-investigates with
+ * broader context, a different capability, or a different role.
+ */
+
+export function shouldShiftStrategy(failureHistory = []) {
+  if (failureHistory.length < 2) return false
+  const last = failureHistory[failureHistory.length - 1] || {}
+  const prev = failureHistory[failureHistory.length - 2] || {}
+  const sameCategory = last.category && last.category === prev.category
+  const sameReason = last.reason && last.reason === prev.reason
+  const sameHypothesis = last.hypothesis && last.hypothesis === prev.hypothesis
+  return Boolean(sameCategory && (sameReason || sameHypothesis))
+}
+
+export function nextStrategy(failureHistory = []) {
+  const last = failureHistory[failureHistory.length - 1] || {}
+  if (last.category === 'test_failure' || last.category === 'build_failure') {
+    return 'Re-investigate root cause with broader context and fresh capability set.'
+  }
+  if (last.category === 'permission_auth') {
+    return 'Check credentials/scopes and switch to an approved auth path.'
+  }
+  if (last.category === 'dependency_issue') {
+    return 'Re-resolve dependency graph and pin compatible versions.'
+  }
+  if (last.category === 'scope_change') {
+    return 'Re-plan with the user to narrow or clarify scope.'
+  }
+  return 'Expand context, re-diagnose from evidence, and try a different approach.'
+}

package/test/agent-runtime.test.mjs

@@ -163,3 +163,15 @@ test('runDagLoop calls onProgress after each batch', async () => {
   assert.ok(snapshots.length >= dag.tasks.length)
   assert.ok(snapshots.every((s) => s.dag && Array.isArray(s.actions)))
 })
+
+test('runDagLoop triggers strategy shift after repeated same failure', async () => {
+  const dag = createMissionDag(buildMission('修复 bug', { taskType: 'bugfix' }))
+  const result = await runDagLoop(dag, {
+    act: async () => ({ ok: true }),
+    observe: async () => ({ type: 'test_failure', reason: 'same root cause' }),
+    maxSteps: 30,
+    maxParallel: 1,
+  })
+  const shiftTasks = result.dag.tasks.filter((t) => /Strategy shift/i.test(t.goal))
+  assert.ok(shiftTasks.length > 0)
+})

package/test/capability-performance.test.mjs

@@ -1,12 +1,17 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 
 import {
   createPerformanceRegistry,
   evaluateProviderValue,
   formatPerformanceRegistry,
+  loadPerformanceRegistry,
   recommendDemotion,
   recordProvisionOutcome,
+  savePerformanceRegistry,
 } from '../src/capability-performance.mjs'
 
 test('recordProvisionOutcome stores before/after metrics', () => {
@@ -62,3 +67,18 @@ test('formatPerformanceRegistry renders entries', () => {
   registry = recordProvisionOutcome(registry, 'p', { successBefore: 0.5, successAfter: 0.9 })
   assert.match(formatPerformanceRegistry(registry), /p/)
 })
+
+test('loadPerformanceRegistry and savePerformanceRegistry persist outcomes', () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'cap-perf-'))
+  try {
+    let registry = createPerformanceRegistry()
+    registry = recordProvisionOutcome(registry, 'plugin-x', { successBefore: 0.7, successAfter: 0.9 })
+    const file = savePerformanceRegistry(cwd, registry)
+    assert.ok(fs.existsSync(file))
+    const loaded = loadPerformanceRegistry(cwd)
+    assert.ok(loaded.providers['plugin-x'])
+    assert.equal(evaluateProviderValue(loaded.providers['plugin-x']).label, 'high')
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true })
+  }
+})

package/test/context-capsule.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  buildContextCapsule,
+  expandContextCapsule,
+} from '../src/context-capsule.mjs'
+
+const entries = [
+  { name: 'src/auth/session.ts', type: 'file' },
+  { name: 'src/middleware/auth.ts', type: 'file' },
+  { name: 'tests/session-concurrency.test.ts', type: 'file' },
+  { name: 'README.md', type: 'file' },
+]
+const files = {
+  'src/auth/session.ts': 'export function refreshSession() { /* refresh logic */ }',
+  'src/middleware/auth.ts': 'import { refreshSession } from "../auth/session"',
+  'tests/session-concurrency.test.ts': 'test("one refresh per session", () => {})',
+  'README.md': '# Project readme',
+}
+const graph = {
+  'src/middleware/auth.ts': [{ to: 'src/auth/session.ts', kind: 'import' }],
+}
+
+test('buildContextCapsule includes only relevant files and tests', () => {
+  const capsule = buildContextCapsule('Fix session refresh race condition', {
+    entries,
+    files,
+    graph,
+    needs: ['callers of refreshSession', 'tests related to concurrent refresh'],
+    invariants: ['one refresh request per session'],
+    failures: ['expected 1 refresh, got 3'],
+    maxFiles: 3,
+  })
+  assert.match(capsule, /src\/auth\/session\.ts/)
+  assert.match(capsule, /session-concurrency\.test\.ts/)
+  assert.match(capsule, /one refresh request per session/)
+  assert.match(capsule, /expected 1 refresh, got 3/)
+  assert.doesNotMatch(capsule, /README\.md/)
+})
+
+test('buildContextCapsule truncates to maxTotalChars', () => {
+  const capsule = buildContextCapsule('x', { entries, files, graph, maxTotalChars: 100 })
+  assert.ok(capsule.length <= 100 + 64)
+  assert.match(capsule, /truncated/)
+})
+
+test('expandContextCapsule appends requested context', () => {
+  const base = buildContextCapsule('fix login', { entries, files, graph })
+  const expanded = expandContextCapsule(base, ['tests related to concurrent refresh'], { entries, files, graph })
+  assert.match(expanded, /additional context requested/)
+  assert.match(expanded, /session-concurrency/)
+})

package/test/progressive-intelligence.test.mjs

@@ -0,0 +1,39 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  INTELLIGENCE_LEVELS,
+  decideIntelligenceLevel,
+  formatIntelligenceLevel,
+} from '../src/progressive-intelligence.mjs'
+
+test('decideIntelligenceLevel maps direct low-risk tasks to L0', () => {
+  const level = decideIntelligenceLevel({ complexity: 'direct', risk: 'low', type: 'other' })
+  assert.equal(level.level, 'L0')
+  assert.equal(level.useDag, false)
+  assert.equal(level.verification, 'light')
+})
+
+test('decideIntelligenceLevel maps balanced coding tasks to L1', () => {
+  const level = decideIntelligenceLevel({ complexity: 'balanced', risk: 'low', type: 'bugfix' })
+  assert.equal(level.level, 'L1')
+  assert.equal(level.useSubagents, false)
+})
+
+test('decideIntelligenceLevel maps plan complexity to L2', () => {
+  const level = decideIntelligenceLevel({ complexity: 'plan', risk: 'low', type: 'feature' })
+  assert.equal(level.level, 'L2')
+  assert.equal(level.useDag, true)
+})
+
+test('decideIntelligenceLevel maps high risk to L3 guarded', () => {
+  const level = decideIntelligenceLevel({ complexity: 'direct', risk: 'high', type: 'bugfix' })
+  assert.equal(level.level, 'L3')
+  assert.equal(level.approvalRequired, true)
+  assert.equal(level.independentVerify, true)
+})
+
+test('INTELLIGENCE_LEVELS and formatter are stable', () => {
+  assert.deepEqual(INTELLIGENCE_LEVELS, ['L0', 'L1', 'L2', 'L3'])
+  assert.match(formatIntelligenceLevel({ level: 'L2', label: 'Orchestrated', description: 'x' }), /L2 Orchestrated/)
+})

package/test/strategy-shift.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  nextStrategy,
+  shouldShiftStrategy,
+} from '../src/strategy-shift.mjs'
+
+test('shouldShiftStrategy returns false for single or different failures', () => {
+  assert.equal(shouldShiftStrategy([]), false)
+  assert.equal(shouldShiftStrategy([{ category: 'test_failure', reason: 'a' }]), false)
+  assert.equal(shouldShiftStrategy([
+    { category: 'test_failure', reason: 'a' },
+    { category: 'build_failure', reason: 'b' },
+  ]), false)
+})
+
+test('shouldShiftStrategy returns true when same category and reason repeat', () => {
+  assert.equal(shouldShiftStrategy([
+    { category: 'test_failure', reason: 'same', hypothesis: 'h' },
+    { category: 'test_failure', reason: 'same', hypothesis: 'h' },
+  ]), true)
+})
+
+test('nextStrategy returns a recovery suggestion', () => {
+  const strategy = nextStrategy([{ category: 'test_failure' }])
+  assert.match(strategy, /Re-investigate/)
+})