dsh-omni-router 2.1.0 → 2.2.0

package/README.md

@@ -73,6 +73,7 @@
 - **Stage 4（部分）**：`compileDagToWorkflow` 将 Mission DAG 编译为 DSH-native workflow outline。
 - **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。
 - **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 增强。
@@ -154,7 +155,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_visual_check`.
+- 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`.
 
 ## Configuration
 

package/README.zh-CN.md

@@ -73,6 +73,7 @@
 - **Stage 4（部分）**：`compileDagToWorkflow` 将 Mission DAG 编译为 DSH-native workflow outline。
 - **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。
 - **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 增强。
@@ -154,7 +155,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_visual_check`。
+- 模型工具：`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`。
 
 ## 配置
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-omni-router",
-  "version": "2.1.0",
+  "version": "2.2.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/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/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/capability-auditor.mjs

@@ -0,0 +1,90 @@
+/**
+ * Capability Auditor.
+ *
+ * Answers "what does the current Harness environment lack?" for both a
+ * baseline (first-run / after DSH update) and a specific task. It is the
+ * front door of the Capability Auto-Provisioning loop.
+ */
+
+export const OMNI_CODING_BASELINE = [
+  'repository.read',
+  'repository.search',
+  'source.write',
+  'shell',
+  'test.run',
+  'debugging',
+  'verification',
+  'code.review',
+  'git.workflow',
+]
+
+const SEVERITY = {
+  'repository.read': 'high',
+  'repository.search': 'high',
+  'source.write': 'high',
+  'shell': 'high',
+  'test.run': 'high',
+  'debugging': 'high',
+  'verification': 'high',
+  'code.review': 'medium',
+  'git.workflow': 'medium',
+  'browser.navigation': 'medium',
+  'browser.interaction': 'medium',
+  'browser.screenshot': 'medium',
+  'frontend.validation': 'medium',
+  'github.remote': 'medium',
+  'gitlab.remote': 'medium',
+  'db.inspection': 'low',
+  'container.run': 'low',
+  'security.review': 'medium',
+  'performance.analysis': 'low',
+}
+
+export function severityForCapability(capability) {
+  return SEVERITY[capability] || 'low'
+}
+
+export function auditCapabilities(brain, required = []) {
+  const availableSet = new Set()
+  for (const provider of brain?.capabilities || []) {
+    for (const cap of provider.capabilities || []) availableSet.add(cap)
+  }
+  const requiredList = [...new Set(required.map((c) => String(c).trim()).filter(Boolean))]
+  const available = requiredList.filter((c) => availableSet.has(c))
+  const missing = requiredList.filter((c) => !availableSet.has(c))
+  return {
+    required: requiredList,
+    available,
+    missing,
+    coverage: requiredList.length ? Math.round((available.length / requiredList.length) * 1000) / 1000 : 1,
+    gaps: missing.map((capability) => ({
+      capability,
+      severity: severityForCapability(capability),
+    })),
+  }
+}
+
+export function baselineAudit(brain, baseline = OMNI_CODING_BASELINE) {
+  return auditCapabilities(brain, baseline)
+}
+
+export function taskTimeAudit(brain, requirements = []) {
+  return auditCapabilities(brain, requirements)
+}
+
+export function formatCapabilityAudit(audit = {}) {
+  const lines = [
+    `Capability audit: ${audit.available?.length || 0}/${audit.required?.length || 0} available (coverage ${audit.coverage ?? 0})`,
+  ]
+  if (audit.required?.length) lines.push(`Required: ${audit.required.join(', ')}`)
+  if (audit.available?.length) lines.push(`Available: ${audit.available.join(', ')}`)
+  if (audit.missing?.length) {
+    lines.push(`Missing (${audit.missing.length}):`)
+    for (const gap of audit.gaps || []) {
+      lines.push(`- ${gap.capability} [${gap.severity}]`)
+    }
+  } else {
+    lines.push('No missing capabilities.')
+  }
+  return lines.join('\n')
+}

package/src/capability-performance.mjs

@@ -0,0 +1,103 @@
+/**
+ * Capability Performance Learning.
+ *
+ * Tracks whether a provisioned plugin/skill actually improves task success,
+ * reduces false completion, or only adds token/catalog overhead. This feeds
+ * demotion/removal decisions and benchmark plugin-contribution analysis.
+ */
+
+export function createPerformanceRegistry(initial = {}) {
+  return {
+    providers: { ...(initial.providers || {}) },
+  }
+}
+
+export function recordProvisionOutcome(registry, providerId, outcome = {}) {
+  const previous = registry.providers[providerId] || {
+    runs: 0,
+    successBefore: null,
+    successAfter: null,
+    falseCompletionBefore: null,
+    falseCompletionAfter: null,
+    tokensBefore: null,
+    tokensAfter: null,
+    toolErrorsBefore: null,
+    toolErrorsAfter: null,
+  }
+  const next = {
+    ...previous,
+    runs: (previous.runs || 0) + 1,
+    successBefore: outcome.successBefore ?? previous.successBefore,
+    successAfter: outcome.successAfter ?? previous.successAfter,
+    falseCompletionBefore: outcome.falseCompletionBefore ?? previous.falseCompletionBefore,
+    falseCompletionAfter: outcome.falseCompletionAfter ?? previous.falseCompletionAfter,
+    tokensBefore: outcome.tokensBefore ?? previous.tokensBefore,
+    tokensAfter: outcome.tokensAfter ?? previous.tokensAfter,
+    toolErrorsBefore: outcome.toolErrorsBefore ?? previous.toolErrorsBefore,
+    toolErrorsAfter: outcome.toolErrorsAfter ?? previous.toolErrorsAfter,
+    lastUpdated: new Date().toISOString(),
+  }
+  return {
+    ...registry,
+    providers: {
+      ...registry.providers,
+      [providerId]: next,
+    },
+  }
+}
+
+export function evaluateProviderValue(record = {}) {
+  const hasBefore = record.successBefore !== null && record.successBefore !== undefined
+  const hasAfter = record.successAfter !== null && record.successAfter !== undefined
+  if (!hasBefore || !hasAfter) return { value: 0, label: 'unknown' }
+
+  const successDelta = record.successAfter - record.successBefore
+  const falseCompletionDelta = (record.falseCompletionBefore ?? 0) - (record.falseCompletionAfter ?? 0)
+  const tokenRatio = record.tokensBefore ? Math.max(0, ((record.tokensAfter ?? 0) - record.tokensBefore) / record.tokensBefore) : 0
+  const toolErrorDelta = (record.toolErrorsAfter ?? 0) - (record.toolErrorsBefore ?? 0)
+
+  const value = (
+    successDelta * 0.5 +
+    falseCompletionDelta * 0.3 -
+    tokenRatio * 0.1 -
+    Math.max(0, toolErrorDelta) * 0.1
+  )
+  const rounded = Math.round(value * 1000) / 1000
+  let label = 'neutral'
+  if (rounded >= 0.05) label = 'high'
+  else if (rounded > 0) label = 'medium'
+  else if (rounded < 0) label = 'negative'
+  return { value: rounded, label, successDelta, falseCompletionDelta, tokenRatio, toolErrorDelta }
+}
+
+export function recommendDemotion(registry, providerId, options = {}) {
+  const record = registry.providers[providerId]
+  if (!record) return { providerId, recommendation: 'unknown', reason: 'no performance record' }
+  const value = evaluateProviderValue(record)
+  const usageDays = Number(options.usageDays ?? 0)
+  const uniqueCapabilities = Number(options.uniqueCapabilities ?? 0)
+  const coveredBy = options.coveredBy || []
+
+  if (value.label === 'negative' && usageDays >= 30 && uniqueCapabilities === 0) {
+    return { providerId, recommendation: 'remove', reason: 'negative value, no unique capability, low usage', value }
+  }
+  if (value.label === 'negative') {
+    return { providerId, recommendation: 'demote', reason: 'negative measured value', value }
+  }
+  if (usageDays >= 90 && uniqueCapabilities === 0 && coveredBy.length > 0) {
+    return { providerId, recommendation: 'remove', reason: 'redundant and unused for 90+ days', value }
+  }
+  if (value.label === 'high' || value.label === 'medium') {
+    return { providerId, recommendation: 'keep', reason: 'positive measured value', value }
+  }
+  return { providerId, recommendation: 'watch', reason: 'insufficient signal', value }
+}
+
+export function formatPerformanceRegistry(registry = {}) {
+  const lines = []
+  for (const [id, record] of Object.entries(registry.providers || {})) {
+    const value = evaluateProviderValue(record)
+    lines.push(`- ${id}: ${value.label} (${value.value}) runs=${record.runs || 0}`)
+  }
+  return lines.length ? lines.join('\n') : '(empty performance registry)'
+}

package/src/capability-provisioner.mjs

@@ -0,0 +1,223 @@
+/**
+ * Capability Provisioner.
+ *
+ * Discovers candidate plugins/skills/MCPs for missing capabilities, evaluates
+ * them, selects a minimal set, installs through DSH's existing mechanisms, and
+ * verifies/rolls back the result. Omni does not become a marketplace: it
+ * delegates discovery to installed marketplace/hub tools, community adapters,
+ * or explicit commands.
+ */
+
+import { scorePluginCandidate } from './capability-quality.mjs'
+import { solveMinimalSet } from './capability-solver.mjs'
+
+export const TRUST_MODES = ['recommend', 'auto-trusted', 'manual']
+
+export function canAutoInstall(candidate = {}, mode = 'auto-trusted', trustedSources = []) {
+  if (mode === 'manual' || mode === 'recommend') return false
+  const source = candidate.source || candidate.package || ''
+  const trusted = candidate.verified === true || candidate.trustedSource === true || trustedSources.includes(source)
+  const risk = candidate.risk || 'low'
+  if (risk === 'high' || risk === 'critical') return false
+  return trusted
+}
+
+export function createProvisionTransaction({
+  package: pkg,
+  version,
+  source,
+  reason,
+  profile,
+  beforeProfile,
+  installCommand,
+  rollbackCommand,
+} = {}) {
+  return {
+    id: `txn-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+    package: pkg,
+    version,
+    source,
+    reason,
+    profile,
+    beforeProfile,
+    installCommand,
+    rollbackCommand,
+    installedAt: new Date().toISOString(),
+    status: 'pending',
+  }
+}
+
+export async function probeCapability(provider = {}, { tools = [], skills = [], probe } = {}) {
+  const checks = []
+  for (const tool of provider.expectedTools || []) {
+    const ok = tools.includes(tool)
+    checks.push({ type: 'tool', name: tool, ok })
+  }
+  for (const skill of provider.expectedSkills || []) {
+    const ok = skills.includes(skill)
+    checks.push({ type: 'skill', name: skill, ok })
+  }
+  if (typeof probe === 'function') {
+    try {
+      const ok = await probe(provider)
+      checks.push({ type: 'probe', name: provider.id || provider.package || 'probe', ok: !!ok })
+    } catch {
+      checks.push({ type: 'probe', name: provider.id || provider.package || 'probe', ok: false })
+    }
+  }
+  const ok = checks.length === 0 || checks.every((c) => c.ok)
+  return { ok, checks }
+}
+
+export async function rollbackProvision(txn = {}, execute) {
+  if (!txn?.rollbackCommand && typeof execute !== 'function') {
+    return { ok: false, reason: 'no rollback executor or command', txn }
+  }
+  try {
+    if (typeof execute === 'function') {
+      const result = await execute({ type: 'rollback', txn })
+      return { ok: result !== false, txn: { ...txn, status: result === false ? 'rollback_failed' : 'rolled_back' } }
+    }
+    // execute as command runner function (command, cwd?) — kept for adapters.
+    const result = await execute(txn.rollbackCommand, txn)
+    return { ok: result !== false, txn: { ...txn, status: result === false ? 'rollback_failed' : 'rolled_back' } }
+  } catch (error) {
+    return { ok: false, reason: error?.message || String(error), txn: { ...txn, status: 'rollback_failed' } }
+  }
+}
+
+export async function discoverCandidates(missing = [], adapters = [], options = {}) {
+  const seen = new Map()
+  for (const adapter of adapters) {
+    let candidates = []
+    try {
+      if (typeof adapter?.search === 'function') {
+        candidates = await adapter.search(missing, options) || []
+      } else if (typeof adapter === 'function') {
+        candidates = await adapter(missing, options) || []
+      }
+    } catch {
+      candidates = []
+    }
+    for (const candidate of candidates) {
+      const key = candidate.id || candidate.package || candidate.name
+      if (!key) continue
+      if (!seen.has(key)) seen.set(key, { ...candidate, _adapter: adapter.id || adapter.name || 'unknown' })
+    }
+  }
+  return [...seen.values()]
+}
+
+export function evaluateProvisionPlan(missing = [], candidates = [], brain = { capabilities: [] }, options = {}) {
+  const maxPlugins = Number(options.maxPlugins ?? 2)
+  const minScore = Number(options.minScore ?? 0.4)
+  const scored = candidates.map((c) => scorePluginCandidate(c, missing, brain, options))
+  const solution = solveMinimalSet(missing, candidates, { brain, maxPlugins, minScore })
+  return {
+    missing,
+    candidates: scored.sort((a, b) => b.score - a.score),
+    solution,
+    selected: solution.scored,
+    requiresApproval: solution.scored.filter((s) => !canAutoInstall(s.candidate, options.mode || 'auto-trusted', options.trustedSources || [])),
+  }
+}
+
+export async function provisionCapabilities(plan = {}, {
+  execute,
+  profile,
+  mode = 'auto-trusted',
+  trustedSources = [],
+  probeTools = [],
+  probeSkills = [],
+  probe,
+} = {}) {
+  const results = []
+  for (const scored of plan.selected || []) {
+    const candidate = scored.candidate
+    const txn = createProvisionTransaction({
+      package: candidate.package || candidate.id,
+      version: candidate.version,
+      source: candidate.source,
+      reason: plan.missing?.join(', ') || '',
+      profile,
+      beforeProfile: plan.beforeProfile,
+      installCommand: candidate.installCommand,
+      rollbackCommand: candidate.rollbackCommand,
+    })
+    if (!canAutoInstall(candidate, mode, trustedSources)) {
+      results.push({ candidate, status: 'needs_approval', txn })
+      continue
+    }
+    try {
+      if (typeof execute === 'function') {
+        const installResult = await execute({ type: 'install', candidate, profile, txn })
+        if (installResult === false) {
+          results.push({ candidate, status: 'install_failed', txn: { ...txn, status: 'install_failed' } })
+          continue
+        }
+      } else if (candidate.installCommand) {
+        // No executor provided; command-based install is left to the caller.
+        results.push({ candidate, status: 'install_command_ready', txn })
+        continue
+      } else {
+        results.push({ candidate, status: 'no_executor', txn })
+        continue
+      }
+      const probeResult = await probeCapability(candidate, { tools: probeTools, skills: probeSkills, probe })
+      if (!probeResult.ok) {
+        const rollback = await rollbackProvision({ ...txn, status: 'probe_failed' }, execute)
+        results.push({ candidate, status: rollback.ok ? 'rolled_back' : 'rollback_failed', txn: rollback.txn, probe: probeResult })
+        continue
+      }
+      results.push({ candidate, status: 'ready', txn: { ...txn, status: 'ready' }, probe: probeResult })
+    } catch (error) {
+      results.push({ candidate, status: 'error', error: error?.message || String(error), txn: { ...txn, status: 'error' } })
+    }
+  }
+  return { results, summary: summarizeProvisionResults(results) }
+}
+
+export function summarizeProvisionResults(results = []) {
+  const counts = {}
+  for (const r of results) counts[r.status] = (counts[r.status] || 0) + 1
+  return counts
+}
+
+export function formatProvisionResult(result = {}) {
+  const lines = []
+  for (const r of result.results || []) {
+    lines.push(`- ${r.candidate?.id || r.candidate?.package}: ${r.status}${r.error ? ` (${r.error})` : ''}`)
+    if (r.probe?.checks?.length) {
+      for (const check of r.probe.checks) lines.push(`  ${check.ok ? '✓' : '✗'} ${check.type} ${check.name}`)
+    }
+  }
+  return lines.join('\n')
+}
+
+// --- Discovery adapters -----------------------------------------------------
+
+export function createMarketplaceAdapter({ search, id = 'marketplace' } = {}) {
+  return {
+    id,
+    async search(missing, options) {
+      if (typeof search !== 'function') return []
+      return search(missing, options)
+    },
+  }
+}
+
+export function createHubAdapter({ search, id = 'hub' } = {}) {
+  return createMarketplaceAdapter({ search, id })
+}
+
+export function createStaticRegistryAdapter(registry = [], id = 'registry') {
+  return {
+    id,
+    async search(missing, options = {}) {
+      const missingSet = new Set(missing)
+      return registry
+        .filter((candidate) => (candidate.provides || []).some((c) => missingSet.has(c)))
+        .map((candidate) => ({ ...candidate, source: candidate.source || 'static-registry' }))
+    },
+  }
+}

package/src/capability-quality.mjs

@@ -0,0 +1,90 @@
+/**
+ * Plugin / Skill Quality Scoring.
+ *
+ * Ranks candidate capability providers by capability fit, reliability,
+ * security/trust, maintenance, community adoption, performance, and an overlap
+ * penalty that keeps the tool catalog minimal.
+ */
+
+const WEIGHTS = {
+  fit: 0.30,
+  reliability: 0.20,
+  trust: 0.20,
+  maintenance: 0.10,
+  community: 0.10,
+  performance: 0.05,
+}
+
+export function capabilityFit(candidate = {}, required = []) {
+  const provides = new Set(candidate.provides || [])
+  if (!required.length) return 0
+  const covered = required.filter((r) => provides.has(r)).length
+  return covered / required.length
+}
+
+export function overlapWithExisting(candidate = {}, brain = { capabilities: [] }) {
+  const existing = new Set()
+  for (const provider of brain.capabilities || []) {
+    for (const cap of provider.capabilities || []) existing.add(cap)
+  }
+  const provides = candidate.provides || []
+  if (!provides.length) return 0
+  const overlapped = provides.filter((c) => existing.has(c)).length
+  return overlapped / provides.length
+}
+
+export function scorePluginCandidate(candidate = {}, required = [], brain = { capabilities: [] }, options = {}) {
+  const fit = capabilityFit(candidate, required)
+  const reliability = Number(candidate.reliability ?? 0.8)
+  const trust = candidate.verified === true || candidate.trustedSource === true
+    ? 1
+    : Number(candidate.trust ?? 0.4)
+  const maintenance = Number(candidate.maintenance ?? 0.5)
+  const community = Number(candidate.community ?? 0.5)
+  const performance = Number(candidate.performance ?? (1 - Number(candidate.contextCost ?? 0.2)))
+
+  const overlap = options.overlap ?? overlapWithExisting(candidate, brain)
+  const overlapPenalty = 0.05 + Math.min(0.25, overlap * 0.25)
+
+  const raw = (
+    fit * WEIGHTS.fit +
+    reliability * WEIGHTS.reliability +
+    trust * WEIGHTS.trust +
+    maintenance * WEIGHTS.maintenance +
+    community * WEIGHTS.community +
+    performance * WEIGHTS.performance
+  ) - overlapPenalty
+
+  const score = Math.max(0, Math.min(1, Math.round(raw * 1000) / 1000))
+  return {
+    candidate,
+    fit: Math.round(fit * 1000) / 1000,
+    reliability,
+    trust,
+    maintenance,
+    community,
+    performance,
+    overlap: Math.round(overlap * 1000) / 1000,
+    overlapPenalty: Math.round(overlapPenalty * 1000) / 1000,
+    score,
+  }
+}
+
+export function installUtility(candidate = {}, required = [], brain = { capabilities: [] }, options = {}) {
+  const quality = scorePluginCandidate(candidate, required, brain, options)
+  const gain = 1 - quality.overlap
+  const taskFrequency = Number(options.taskFrequency ?? 1)
+  const latencyPenalty = Number(options.latencyPenalty ?? candidate.latency ?? 0)
+  const contextCost = Number(options.contextCost ?? candidate.contextCost ?? 0)
+  const maintenanceCost = Number(options.maintenanceCost ?? (1 - quality.maintenance) * 0.1)
+  const riskPenalty = Number(options.riskPenalty ?? (candidate.risk === 'high' ? 0.15 : candidate.risk === 'critical' ? 0.3 : 0))
+  const utility = quality.score * gain * taskFrequency - latencyPenalty - contextCost - maintenanceCost - riskPenalty
+  return {
+    ...quality,
+    utility: Math.round(utility * 1000) / 1000,
+  }
+}
+
+export function formatCandidateScore(scored) {
+  return `${scored.candidate.id} score=${scored.score} fit=${scored.fit} overlap=${scored.overlap}${scored.utility !== undefined ? ` utility=${scored.utility}` : ''}`
+}

package/src/capability-solver.mjs

@@ -0,0 +1,88 @@
+/**
+ * Minimal Capability Set Solver.
+ *
+ * Chooses the smallest reliable set of plugins/skills that covers the current
+ * task's required capabilities. This is a greedy weighted set cover: maximize
+ * marginal capability gain while minimizing plugin count and risk.
+ */
+
+import { scorePluginCandidate } from './capability-quality.mjs'
+
+export function solveMinimalSet(required = [], candidates = [], options = {}) {
+  const maxPlugins = Number(options.maxPlugins ?? 2)
+  const minScore = Number(options.minScore ?? 0.4)
+  const brain = options.brain || { capabilities: [] }
+  const target = [...new Set(required.filter(Boolean))]
+  const scored = candidates
+    .map((c) => scorePluginCandidate(c, target, brain, options))
+    .filter((s) => s.score >= minScore && s.fit > 0)
+    .sort((a, b) => b.score - a.score)
+
+  const selected = []
+  const covered = new Set()
+  let remaining = target.filter((r) => !covered.has(r))
+  let totalScore = 0
+
+  while (remaining.length > 0 && selected.length < maxPlugins) {
+    let best = null
+    let bestMarginal = -1
+    for (const scoredCandidate of scored) {
+      if (selected.some((s) => s.candidate.id === scoredCandidate.candidate.id)) continue
+      const provides = new Set(scoredCandidate.candidate.provides || [])
+      const newly = remaining.filter((r) => provides.has(r)).length
+      if (newly === 0) continue
+      const marginal = (newly / target.length) * scoredCandidate.score
+      const riskPenalty = scoredCandidate.candidate.risk === 'high' ? 0.05 : scoredCandidate.candidate.risk === 'critical' ? 0.1 : 0
+      const value = marginal - riskPenalty
+      if (value > bestMarginal) {
+        bestMarginal = value
+        best = scoredCandidate
+      }
+    }
+    if (!best) break
+    selected.push(best)
+    totalScore += best.score
+    for (const cap of best.candidate.provides || []) covered.add(cap)
+    remaining = target.filter((r) => !covered.has(r))
+  }
+
+  return {
+    selected: selected.map((s) => s.candidate),
+    scored: selected,
+    covered: [...covered],
+    missing: target.filter((r) => !covered.has(r)),
+    totalScore: Math.round(totalScore * 1000) / 1000,
+    pluginCount: selected.length,
+  }
+}
+
+export function isRedundant(candidate = {}, brain = { capabilities: [] }) {
+  const providers = brain.capabilities || []
+  const candidateId = candidate.id
+  const provides = candidate.provides || candidate.capabilities || []
+  if (!provides.length) return false
+  return provides.every((cap) =>
+    providers.some((p) => p.id !== candidateId && (p.capabilities || []).includes(cap)),
+  )
+}
+
+export function findRedundantProviders(brain = { capabilities: [] }) {
+  return (brain.capabilities || [])
+    .filter((provider) => isRedundant(provider, brain))
+    .map((provider) => ({
+      id: provider.id,
+      capabilities: provider.capabilities || [],
+      reason: 'all capabilities covered by other providers',
+    }))
+}
+
+export function formatSolveResult(result = {}) {
+  const lines = [
+    `Minimal set: ${result.pluginCount ?? 0} provider(s), covered ${result.covered?.length || 0}/${result.required?.length || result.covered?.length || 0}`,
+  ]
+  for (const s of result.scored || []) {
+    lines.push(`- ${s.candidate.id} (score=${s.score}, provides ${(s.candidate.provides || []).join(', ')})`)
+  }
+  if (result.missing?.length) lines.push(`Missing: ${result.missing.join(', ')}`)
+  return lines.join('\n')
+}

package/src/omni-router.mjs

@@ -35,6 +35,8 @@ import { generateMissionDag, roleForTask } from './planner-dag.mjs'
 import { autoPopulateCapabilityBrain, createCapabilityBrain, recordCapabilityOutcome } from './capability-brain.mjs'
 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 { buildProgressiveContext } from './context-expansion.mjs'
 import { buildDynamicContext } from './dynamic-context.mjs'
 import { classifyFailure } from './failure-taxonomy.mjs'
@@ -1468,6 +1470,136 @@ export function apply(ctx, config = {}) {
     return { act, observe, saveProgress, getCapabilityBrain: () => brain }
   }
 
+  registerTool({
+    name: 'omni_capability_audit',
+    description: 'Audit current Harness capabilities against the Omni Coding Baseline or task requirements.',
+    parameters: {
+      type: 'object',
+      properties: {
+        requirements: { type: 'array', items: { type: 'string' }, description: 'Optional task capability requirements' },
+        baseline: { type: 'boolean', description: 'Run baseline audit when no requirements are given (default true)' },
+      },
+    },
+    async execute(args) {
+      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 requirements = Array.isArray(args?.requirements) ? args.requirements.map(String).filter(Boolean) : []
+      const audit = requirements.length ? taskTimeAudit(brain, requirements) : baselineAudit(brain)
+      return formatCapabilityAudit(audit)
+    },
+  })
+
+  registerTool({
+    name: 'omni_capability_provision',
+    description: 'Detect missing capabilities, discover candidate plugins/skills, evaluate a minimal set, and optionally provision after approval/dry-run.',
+    parameters: {
+      type: 'object',
+      properties: {
+        requirements: { type: 'array', items: { type: 'string' }, description: 'Task capability requirements (preferred)' },
+        missing: { type: 'array', items: { type: 'string' }, description: 'Explicit missing capabilities (alternative to requirements)' },
+        mode: { type: 'string', enum: ['recommend', 'auto-trusted', 'manual'], description: 'Provisioning trust mode (default auto-trusted)' },
+        dryRun: { type: 'boolean', description: 'Only evaluate and print the plan (default true)' },
+        maxPlugins: { type: 'number', description: 'Maximum plugins to install for this task (default 2)' },
+        profile: { type: 'string', description: 'DSH profile to provision into (default web)' },
+      },
+      required: [],
+    },
+    async execute(args) {
+      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 provisioning = config.capabilityProvisioning || {}
+      const requirements = Array.isArray(args?.requirements) ? args.requirements.map(String).filter(Boolean) : []
+      const explicitMissing = Array.isArray(args?.missing) ? args.missing.map(String).filter(Boolean) : []
+      const missing = explicitMissing.length
+        ? explicitMissing
+        : requirements.length
+          ? taskTimeAudit(brain, requirements).missing
+          : baselineAudit(brain).missing
+
+      if (!missing.length) return 'No missing capabilities detected.'
+
+      const adapters = [
+        createStaticRegistryAdapter(provisioning.registry || []),
+        ...(Array.isArray(provisioning.adapters) ? provisioning.adapters : []),
+      ]
+      const candidates = await discoverCandidates(missing, adapters)
+      if (!candidates.length) {
+        return `No candidate providers found for: ${missing.join(', ')}`
+      }
+
+      const mode = args?.mode || provisioning.mode || 'auto-trusted'
+      const plan = evaluateProvisionPlan(missing, candidates, brain, {
+        mode,
+        maxPlugins: Number(args?.maxPlugins ?? provisioning.maxTaskPlugins ?? 2),
+        trustedSources: provisioning.trustedSources || [],
+      })
+
+      const lines = [
+        `Missing (${missing.length}): ${missing.join(', ')}`,
+        `Candidates (${candidates.length}):`,
+        ...candidates.map((c) => `- ${c.id || c.package}: ${(c.provides || []).join(', ')}${c.verified ? ' [verified]' : ''}`),
+        '',
+        `Selected minimal set (${plan.selected.length}):`,
+        ...plan.selected.map((s) => `- ${s.candidate.id} score=${s.score}`),
+        `Requires approval: ${plan.requiresApproval.map((s) => s.candidate.id).join(', ') || '(none)'}`,
+        `Still missing: ${plan.solution.missing.join(', ') || '(none)'}`,
+      ]
+
+      if (args?.dryRun !== false) {
+        lines.push('', 'Dry run: no changes made. Set dryRun:false to provision (requires trusted mode + executor).')
+        return lines.join('\n')
+      }
+
+      const result = await provisionCapabilities(plan, {
+        mode,
+        profile: args?.profile || provisioning.profile || 'web',
+        trustedSources: provisioning.trustedSources || [],
+        execute: provisioning.execute,
+        probeTools: toolNames,
+        probeSkills: provisioning.probeSkills || [],
+      })
+      lines.push('', 'Provision result:')
+      lines.push(formatProvisionResult(result))
+      return lines.join('\n')
+    },
+  })
+
+  registerTool({
+    name: 'omni_capability_probe',
+    description: 'Probe whether an installed provider actually exposes its expected tools/skills.',
+    parameters: {
+      type: 'object',
+      properties: {
+        provider: { type: 'string', description: 'Provider id in the Capability Brain' },
+        expectedTools: { type: 'array', items: { type: 'string' }, description: 'Tool names the provider should expose' },
+        expectedSkills: { type: 'array', items: { type: 'string' }, description: 'Skill names the provider should expose' },
+      },
+      required: ['provider'],
+    },
+    async execute(args) {
+      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 provider = (brain.capabilities || []).find((c) => c.id === args?.provider)
+      if (!provider) return `Provider "${args?.provider}" not found in Capability Brain.`
+      const probe = await probeCapability(
+        { ...provider, expectedTools: args?.expectedTools || [], expectedSkills: args?.expectedSkills || [] },
+        { tools: toolNames, skills: config.capabilityProvisioning?.probeSkills || [] },
+      )
+      const lines = [`Probe ${args.provider}: ${probe.ok ? 'READY' : 'BROKEN'}`]
+      for (const check of probe.checks) lines.push(`- ${check.ok ? '✓' : '✗'} ${check.type} ${check.name}`)
+      return lines.join('\n')
+    },
+  })
+
   registerTool({
     name: 'omni_mission_run',
     description: 'Run a Mission Planner loop with real subagents: Observe → Think → Act → Replan until completed or maxSteps.',

package/test/capability-auditor.test.mjs

@@ -0,0 +1,43 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  OMNI_CODING_BASELINE,
+  auditCapabilities,
+  baselineAudit,
+  formatCapabilityAudit,
+  taskTimeAudit,
+} from '../src/capability-auditor.mjs'
+import { createCapabilityBrain, registerCapability } from '../src/capability-brain.mjs'
+
+test('baselineAudit reports missing coding baseline on empty brain', () => {
+  const audit = baselineAudit(createCapabilityBrain())
+  assert.ok(audit.missing.includes('repository.read'))
+  assert.ok(audit.missing.includes('verification'))
+  assert.equal(audit.coverage, 0)
+})
+
+test('auditCapabilities lists available and missing', () => {
+  let brain = createCapabilityBrain()
+  brain = registerCapability(brain, { id: 'fs-tools', capabilities: ['repository.read', 'repository.search', 'source.write'] })
+  const audit = auditCapabilities(brain, ['repository.read', 'source.write', 'test.run', 'browser.screenshot'])
+  assert.deepEqual(audit.available, ['repository.read', 'source.write'])
+  assert.deepEqual(audit.missing, ['test.run', 'browser.screenshot'])
+  assert.equal(audit.coverage, 0.5)
+})
+
+test('taskTimeAudit returns gaps with severity', () => {
+  const audit = taskTimeAudit(createCapabilityBrain(), ['browser.screenshot', 'verification'])
+  assert.equal(audit.gaps.length, 2)
+  assert.ok(audit.gaps.every((g) => g.severity))
+})
+
+test('formatCapabilityAudit renders human-readable summary', () => {
+  const text = formatCapabilityAudit(baselineAudit(createCapabilityBrain()))
+  assert.match(text, /Capability audit/)
+  assert.match(text, /Missing/)
+})
+
+test('OMNI_CODING_BASELINE is defined', () => {
+  assert.ok(OMNI_CODING_BASELINE.length >= 7)
+})

package/test/capability-performance.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  createPerformanceRegistry,
+  evaluateProviderValue,
+  formatPerformanceRegistry,
+  recommendDemotion,
+  recordProvisionOutcome,
+} from '../src/capability-performance.mjs'
+
+test('recordProvisionOutcome stores before/after metrics', () => {
+  let registry = createPerformanceRegistry()
+  registry = recordProvisionOutcome(registry, 'plugin-a', {
+    successBefore: 0.73,
+    successAfter: 0.86,
+    falseCompletionBefore: 0.12,
+    falseCompletionAfter: 0.04,
+    tokensBefore: 1000,
+    tokensAfter: 1080,
+  })
+  assert.equal(registry.providers['plugin-a'].runs, 1)
+  const value = evaluateProviderValue(registry.providers['plugin-a'])
+  assert.equal(value.label, 'high')
+})
+
+test('evaluateProviderValue labels negative outcomes', () => {
+  const value = evaluateProviderValue({
+    successBefore: 0.8,
+    successAfter: 0.81,
+    falseCompletionBefore: 0.1,
+    falseCompletionAfter: 0.1,
+    tokensBefore: 1000,
+    tokensAfter: 1300,
+    toolErrorsBefore: 0,
+    toolErrorsAfter: 5,
+  })
+  assert.equal(value.label, 'negative')
+})
+
+test('recommendDemotion removes negative redundant providers', () => {
+  const registry = createPerformanceRegistry({
+    providers: {
+      'old-plugin': {
+        successBefore: 0.8,
+        successAfter: 0.78,
+        falseCompletionBefore: 0.1,
+        falseCompletionAfter: 0.1,
+        tokensBefore: 1000,
+        tokensAfter: 1200,
+        toolErrorsBefore: 0,
+        toolErrorsAfter: 2,
+      },
+    },
+  })
+  const rec = recommendDemotion(registry, 'old-plugin', { usageDays: 45, uniqueCapabilities: 1 })
+  assert.equal(rec.recommendation, 'demote')
+})
+
+test('formatPerformanceRegistry renders entries', () => {
+  let registry = createPerformanceRegistry()
+  registry = recordProvisionOutcome(registry, 'p', { successBefore: 0.5, successAfter: 0.9 })
+  assert.match(formatPerformanceRegistry(registry), /p/)
+})

package/test/capability-provisioner.test.mjs

@@ -0,0 +1,96 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  canAutoInstall,
+  createHubAdapter,
+  createMarketplaceAdapter,
+  createProvisionTransaction,
+  createStaticRegistryAdapter,
+  discoverCandidates,
+  evaluateProvisionPlan,
+  formatProvisionResult,
+  probeCapability,
+  provisionCapabilities,
+  rollbackProvision,
+} from '../src/capability-provisioner.mjs'
+import { createCapabilityBrain } from '../src/capability-brain.mjs'
+
+test('canAutoInstall enforces trust mode and risk', () => {
+  const verified = { verified: true, risk: 'low' }
+  assert.equal(canAutoInstall(verified, 'auto-trusted'), true)
+  assert.equal(canAutoInstall(verified, 'manual'), false)
+  assert.equal(canAutoInstall({ verified: false, risk: 'low' }, 'auto-trusted'), false)
+  assert.equal(canAutoInstall({ verified: true, risk: 'high' }, 'auto-trusted'), false)
+  assert.equal(canAutoInstall({ source: 'trusted-registry', risk: 'low' }, 'auto-trusted', ['trusted-registry']), true)
+})
+
+test('static registry adapter discovers matching candidates', async () => {
+  const adapter = createStaticRegistryAdapter([
+    { id: 'browser-kit', provides: ['browser.screenshot', 'frontend.validation'], verified: true, reliability: 0.9 },
+    { id: 'git-kit', provides: ['github.read'], verified: true, reliability: 0.9 },
+  ])
+  const candidates = await discoverCandidates(['browser.screenshot', 'github.read'], [adapter])
+  assert.equal(candidates.length, 2)
+})
+
+test('marketplace and hub adapters delegate search', async () => {
+  const marketplace = createMarketplaceAdapter({ search: async () => [{ id: 'mp', provides: ['test.run'] }] })
+  const hub = createHubAdapter({ search: async () => [{ id: 'hub', provides: ['debugging'] }] })
+  const candidates = await discoverCandidates(['test.run', 'debugging'], [marketplace, hub])
+  assert.deepEqual(candidates.map((c) => c.id).sort(), ['hub', 'mp'])
+})
+
+test('evaluateProvisionPlan selects minimal set and flags approval', () => {
+  const brain = createCapabilityBrain()
+  const candidates = [
+    { id: 'trusted', provides: ['test.run', 'debugging'], verified: true, reliability: 0.9, risk: 'low' },
+    { id: 'untrusted', provides: ['test.run', 'debugging'], verified: false, reliability: 0.9, risk: 'medium' },
+  ]
+  const plan = evaluateProvisionPlan(['test.run', 'debugging'], candidates, brain, { mode: 'auto-trusted', maxPlugins: 1 })
+  assert.equal(plan.selected.length, 1)
+  assert.equal(plan.selected[0].candidate.id, 'trusted')
+  assert.equal(plan.requiresApproval.length, 0)
+})
+
+test('provisionCapabilities installs, probes, and rolls back on probe failure', async () => {
+  const plan = {
+    missing: ['test.run'],
+    selected: [{
+      candidate: { id: 'test-kit', package: 'test-kit', provides: ['test.run'], verified: true, risk: 'low', rollbackCommand: 'remove test-kit', expectedTools: ['test_runner'] },
+      score: 0.9,
+    }],
+  }
+  const calls = []
+  const result = await provisionCapabilities(plan, {
+    mode: 'auto-trusted',
+    execute: async ({ type, candidate, txn }) => {
+      calls.push(type)
+      if (type === 'install') return true
+      if (type === 'rollback') return true
+      return false
+    },
+    probeTools: [],
+  })
+  // probe fails because expected tool is missing, so rollback path runs
+  assert.equal(result.results[0].status, 'rolled_back')
+  assert.ok(calls.includes('install'))
+  assert.ok(calls.includes('rollback'))
+})
+
+test('probeCapability checks tools and skills', async () => {
+  const provider = { expectedTools: ['browser_screenshot'], expectedSkills: ['frontend-validation'] }
+  const ok = await probeCapability(provider, { tools: ['browser_screenshot'], skills: ['frontend-validation'] })
+  assert.equal(ok.ok, true)
+  const bad = await probeCapability(provider, { tools: [], skills: [] })
+  assert.equal(bad.ok, false)
+})
+
+test('createProvisionTransaction and rollbackProvision', async () => {
+  const txn = createProvisionTransaction({ package: 'x', rollbackCommand: 'remove x' })
+  assert.equal(txn.status, 'pending')
+  const rollback = await rollbackProvision(txn, async () => true)
+  assert.equal(rollback.ok, true)
+  assert.equal(rollback.txn.status, 'rolled_back')
+  assert.match(formatProvisionResult({ results: [] }), /^$/)
+})

package/test/capability-quality.test.mjs

@@ -0,0 +1,62 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  capabilityFit,
+  formatCandidateScore,
+  installUtility,
+  overlapWithExisting,
+  scorePluginCandidate,
+} from '../src/capability-quality.mjs'
+import { createCapabilityBrain, registerCapability } from '../src/capability-brain.mjs'
+
+test('capabilityFit measures required coverage', () => {
+  const candidate = { provides: ['browser.navigation', 'browser.interaction'] }
+  assert.equal(capabilityFit(candidate, ['browser.navigation', 'browser.interaction', 'browser.screenshot']), 2 / 3)
+})
+
+test('overlapWithExisting penalizes duplicate capabilities', () => {
+  let brain = createCapabilityBrain()
+  brain = registerCapability(brain, { id: 'existing', capabilities: ['browser.navigation', 'browser.screenshot'] })
+  const candidate = { provides: ['browser.navigation', 'browser.screenshot', 'github.read'] }
+  assert.equal(overlapWithExisting(candidate, brain), 2 / 3)
+})
+
+test('scorePluginCandidate ranks trusted reliable providers higher', () => {
+  const required = ['browser.navigation', 'browser.interaction', 'browser.screenshot', 'github.read']
+  const good = scorePluginCandidate({
+    id: 'good',
+    provides: required,
+    verified: true,
+    reliability: 0.95,
+    maintenance: 0.9,
+    community: 0.8,
+    risk: 'low',
+  }, required, createCapabilityBrain())
+  const bad = scorePluginCandidate({
+    id: 'bad',
+    provides: required,
+    verified: false,
+    reliability: 0.4,
+    maintenance: 0.2,
+    community: 0.1,
+    risk: 'high',
+  }, required, createCapabilityBrain())
+  assert.ok(good.score > bad.score)
+})
+
+test('overlap penalty lowers score', () => {
+  let brain = createCapabilityBrain()
+  brain = registerCapability(brain, { id: 'existing', capabilities: ['browser.navigation', 'browser.interaction'] })
+  const candidate = { id: 'dup', provides: ['browser.navigation', 'browser.interaction'], verified: true, reliability: 0.9 }
+  const lowOverlap = scorePluginCandidate(candidate, ['browser.navigation', 'browser.interaction', 'github.read'], brain, { overlap: 0 })
+  const highOverlap = scorePluginCandidate(candidate, ['browser.navigation', 'browser.interaction', 'github.read'], brain, { overlap: 1 })
+  assert.ok(lowOverlap.score > highOverlap.score)
+})
+
+test('installUtility includes overhead penalties', () => {
+  const candidate = { id: 'x', provides: ['test.run'], verified: true, reliability: 0.9, risk: 'low' }
+  const utility = installUtility(candidate, ['test.run'], createCapabilityBrain(), { taskFrequency: 2, latencyPenalty: 0.1, contextCost: 0.1 })
+  assert.equal(typeof utility.utility, 'number')
+  assert.match(formatCandidateScore(utility), /x/)
+})

package/test/capability-solver.test.mjs

@@ -0,0 +1,51 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  findRedundantProviders,
+  formatSolveResult,
+  isRedundant,
+  solveMinimalSet,
+} from '../src/capability-solver.mjs'
+import { createCapabilityBrain, registerCapability } from '../src/capability-brain.mjs'
+
+test('solveMinimalSet prefers one comprehensive provider over many', () => {
+  const required = ['browser.navigation', 'browser.interaction', 'browser.screenshot', 'github.read']
+  const candidates = [
+    { id: 'a', provides: ['browser.navigation', 'browser.interaction'], verified: true, reliability: 0.9, risk: 'low' },
+    { id: 'b', provides: ['browser.screenshot'], verified: true, reliability: 0.9, risk: 'low' },
+    { id: 'c', provides: ['browser.navigation', 'browser.interaction', 'browser.screenshot', 'github.read'], verified: true, reliability: 0.95, risk: 'low' },
+    { id: 'd', provides: ['github.read'], verified: true, reliability: 0.9, risk: 'low' },
+  ]
+  const result = solveMinimalSet(required, candidates, { maxPlugins: 2, minScore: 0.4 })
+  assert.ok(result.selected.some((c) => c.id === 'c'))
+  assert.equal(result.missing.length, 0)
+  assert.ok(result.pluginCount <= 2)
+  assert.match(formatSolveResult(result), /Minimal set/)
+})
+
+test('solveMinimalSet stops at maxPlugins and reports missing', () => {
+  const result = solveMinimalSet(
+    ['a', 'b', 'c'],
+    [{ id: 'only-a', provides: ['a'], verified: true, reliability: 0.9 }],
+    { maxPlugins: 1, minScore: 0.4 },
+  )
+  assert.equal(result.pluginCount, 1)
+  assert.deepEqual(result.missing, ['b', 'c'])
+})
+
+test('isRedundant detects providers fully covered by others', () => {
+  let brain = createCapabilityBrain()
+  brain = registerCapability(brain, { id: 'mega', capabilities: ['browser.navigation', 'browser.interaction', 'browser.screenshot'] })
+  brain = registerCapability(brain, { id: 'mini', capabilities: ['browser.navigation', 'browser.interaction'] })
+  assert.equal(isRedundant({ id: 'mini', provides: ['browser.navigation', 'browser.interaction'] }, brain), true)
+  assert.equal(isRedundant({ id: 'mega', provides: ['browser.navigation', 'browser.interaction', 'browser.screenshot'] }, brain), false)
+})
+
+test('findRedundantProviders returns covered providers', () => {
+  let brain = createCapabilityBrain()
+  brain = registerCapability(brain, { id: 'mega', capabilities: ['browser.navigation', 'browser.interaction', 'browser.screenshot'] })
+  brain = registerCapability(brain, { id: 'mini', capabilities: ['browser.navigation', 'browser.interaction'] })
+  const redundant = findRedundantProviders(brain)
+  assert.ok(redundant.some((r) => r.id === 'mini'))
+})