mio-agent-runtime 0.13.4 → 0.14.0

package/server/creativity-sources.js

@@ -0,0 +1,186 @@
+'use strict'
+
+// Source auto-aggregation for the creativity engine (spec Capability 2).
+//
+// Default providers read ONLY local MIO_HOME data — zero network. Insight and
+// observer sources arrive as plain arrays from the caller, because only the
+// entry point knows which store is authoritative (MIO_HOME for the CLI, the
+// MCP server's MIO_DATA_DIR) and whether its optional package resolves.
+// SourceAggregator already tolerates a throwing provider (per-provider
+// try/catch with a WARN log), so providers here do not need extra guards.
+
+const fs = require('fs')
+const path = require('path')
+const { SourceAggregator } = require('@akemi-mio/creativity/SourceAggregator')
+const { sourcesFromInsights, isoOf } = require('./creativity-engine.js')
+
+function readJsonl(file) {
+  try {
+    return fs
+      .readFileSync(file, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        try { return JSON.parse(line) } catch { return null }
+      })
+      .filter(Boolean)
+  } catch (_) {
+    return []
+  }
+}
+
+// Every weight is > 0.7 on purpose: IdeaGenerator.applyTemperature keeps any
+// source with weight > 0.7 unconditionally (temperature 0.5 middle branch), so
+// the assembled set reaches the prompt intact — deterministic, no RNG survival.
+const WEIGHTS = {
+  memory: 0.75,
+  traceOk: 0.74,
+  traceFail: 0.73,
+  hypothesisActive: 0.72,
+  hypothesisRejected: 0.72,
+  trend: 0.76,
+}
+
+function memoryProvider(dataDir) {
+  return {
+    domain: 'feedback',
+    name: 'memory',
+    collect() {
+      return readJsonl(path.join(dataDir, 'memory.jsonl'))
+        .filter((r) => r && r.archived !== true && (r.kind === 'decision' || r.kind === 'note'))
+        .slice(-6)
+        .map((r) => ({
+          name: `${r.kind}: ${String(r.content || '').slice(0, 40)}`,
+          content: String(r.content || ''),
+          type: 'feedback',
+          weight: WEIGHTS.memory,
+          origin: `memory:${r.id}`,
+          originId: r.id,
+          timestamp: isoOf(r.timestamp),
+        }))
+    },
+  }
+}
+
+function traceProviders(dataDir) {
+  const events = () => readJsonl(path.join(dataDir, 'traces.jsonl')).slice(-40)
+  const fmt = (r) => `${r.event_type}${r.outcome ? `/${r.outcome}` : ''}: ${JSON.stringify(r.payload || {}).slice(0, 300)}`
+  const stamp = (r) => isoOf(r.timestamp ?? r.ts)
+  return [
+    {
+      domain: 'behavior',
+      name: 'traces-success',
+      collect() {
+        return events()
+          .filter((r) => r.event_type === 'task_outcome' && r.outcome === 'success')
+          .slice(-3)
+          .map((r) => ({
+            name: `success: ${String((r.payload && (r.payload.task || r.payload.summary)) || r.trace_id || 'task').slice(0, 40)}`,
+            content: fmt(r),
+            type: 'behavior',
+            weight: WEIGHTS.traceOk,
+            origin: `trace:${r.trace_id}`,
+            originId: r.trace_id,
+            timestamp: stamp(r),
+          }))
+      },
+    },
+    {
+      domain: 'failure',
+      name: 'traces-failure',
+      collect() {
+        return events()
+          .filter(
+            (r) =>
+              (r.event_type === 'error' || r.event_type === 'retry') ||
+              (r.event_type === 'task_outcome' && (r.outcome === 'failure' || r.outcome === 'error' || r.outcome === 'aborted')),
+          )
+          .slice(-3)
+          .map((r) => ({
+            name: `failure: ${String(r.event_type)}${r.trace_id ? ` ${String(r.trace_id).slice(0, 12)}` : ''}`,
+            content: fmt(r),
+            type: 'failure',
+            weight: WEIGHTS.traceFail,
+            origin: `trace:${r.trace_id || 'unknown'}`,
+            originId: r.trace_id,
+            timestamp: stamp(r),
+          }))
+      },
+    },
+  ]
+}
+
+function hypothesesProvider(dataDir) {
+  return {
+    domain: 'module',
+    name: 'hypotheses',
+    collect() {
+      return readJsonl(path.join(dataDir, 'creativity', 'creativity-hypotheses.jsonl'))
+        .filter((h) => h && (h.status === 'active' || h.status === 'rejected'))
+        .slice(-6)
+        .map((h) => ({
+          name: String(h.title || h.id).slice(0, 60),
+          content: `idea: ${h.idea}\nrisk: ${h.risk || '-'}`,
+          type: h.status === 'rejected' ? 'failure' : 'knowledge',
+          weight: h.status === 'rejected' ? WEIGHTS.hypothesisRejected : WEIGHTS.hypothesisActive,
+          origin: `hypothesis:${h.id}`,
+          originId: h.id,
+          timestamp: isoOf(h.createdAt),
+        }))
+    },
+  }
+}
+
+// Observer trend reports → provocation sources. The report schema has drifted
+// across observer versions, so fields are read defensively with fallbacks.
+function trendSources(trends) {
+  return (Array.isArray(trends) ? trends : []).slice(0, 4).map((t, i) => {
+    const title = (t && (t.title || t.name || t.date)) || `trend-${i}`
+    const body =
+      (t && t.summary) ||
+      (Array.isArray(t && t.themes) ? t.themes.join('; ') : '') ||
+      JSON.stringify(t || {}).slice(0, 400)
+    const key = (t && (t.date || t.id)) || String(i)
+    const stamp = isoOf(t && (t.generatedAt || t.date))
+    return {
+      name: String(title).slice(0, 60),
+      content: String(body),
+      type: 'provocation',
+      weight: WEIGHTS.trend,
+      origin: `observer-trends:${key}`,
+      ...(t && t.id ? { originId: t.id } : {}),
+      ...(stamp ? { timestamp: stamp } : {}),
+    }
+  })
+}
+
+// Assemble every local (+ optionally insight/observer) domain through the
+// package SourceAggregator so dedup, per-domain caps and failure tolerance
+// behave identically for idea.generate and the generate top-up.
+function buildAutoSources({ dataDir, insights = [], trends = [] }) {
+  const aggregator = new SourceAggregator(4, 1)
+  aggregator.addProvider(memoryProvider(dataDir))
+  for (const provider of traceProviders(dataDir)) aggregator.addProvider(provider)
+  aggregator.addProvider(hypothesesProvider(dataDir))
+  if (Array.isArray(insights) && insights.length > 0) {
+    aggregator.addProvider({ domain: 'observation', name: 'insight', collect: () => sourcesFromInsights(insights) })
+  }
+  const trendList = Array.isArray(trends) ? trends : []
+  if (trendList.length > 0) {
+    aggregator.addProvider({ domain: 'external', name: 'observer-trends', collect: () => trendSources(trendList) })
+  }
+  return aggregator.build()
+}
+
+// Explicit --source entries always win: auto sources only top a set up to the
+// two entries the concept mixer needs; they never replace or reorder explicit
+// ones (spec Capability 2, injection point 2).
+function topUpSources(explicit, auto) {
+  const list = Array.isArray(explicit) ? explicit.filter(Boolean) : []
+  if (list.length >= 2) return list
+  const seen = new Set(list.map((s) => s.name))
+  const extra = (Array.isArray(auto) ? auto : []).filter((s) => s && !seen.has(s.name))
+  return [...list, ...extra]
+}
+
+module.exports = { buildAutoSources, topUpSources, trendSources, memoryProvider, traceProviders, hypothesesProvider }

package/server/evolution-cutover.js

@@ -72,13 +72,16 @@ function createEvolutionCutoverTools({ dataDir, appendJsonl, readJsonl, projectN
     const project = projectFromArgs(args)
     const shadowRuns = readJsonl(shadowPath).filter((record) => record.project === project)
     const dualWriteRuns = readJsonl(dualWritePath).filter((record) => record.project === project)
+    // Apply documented defaults (schema says minShadowRuns: 5, maxMismatchRate: 0)
+    const minShadowRuns = Number.isFinite(args.minShadowRuns) ? args.minShadowRuns : 5
+    const maxMismatchRate = Number.isFinite(args.maxMismatchRate) ? args.maxMismatchRate : 0
     return {
       project,
       ...assessCutoverReadiness({
         shadowRuns,
         dualWriteRuns,
-        minShadowRuns: Number.isFinite(args.minShadowRuns) ? args.minShadowRuns : undefined,
-        maxMismatchRate: Number.isFinite(args.maxMismatchRate) ? args.maxMismatchRate : undefined,
+        minShadowRuns,
+        maxMismatchRate,
       }),
     }
   }

package/server/idea-generate.js

@@ -0,0 +1,136 @@
+'use strict'
+
+// `mio.idea.generate` — one-shot goal-driven idea pipeline (spec Capability 1).
+// Shared by the CLI (`mio idea generate`) and the MCP server (tool
+// `mio.idea.generate`): each entry point only assembles entry-specific inputs
+// (which store is authoritative, where local data lives) and renders the
+// response this module returns.
+//
+// Contract:
+//   - source order: goal → context → constraints → grounding → local auto,
+//     deduplicated by `origin` (fallback name), first occurrence wins — so a
+//     memory that arrives both as a grounding hit and through the local
+//     provider contributes exactly once, the grounding copy first;
+//   - pairing strategy: cross-type `explore` only when two types exist, else
+//     the `stable` fallback (an all-knowledge set explores into ZERO combos);
+//   - every candidate passes evaluateNovelty against stored hypotheses: a
+//     near-duplicate of a REJECTED one is persisted as rejected with a reason,
+//     a merely-similar recent one is down-scored; drafts AND rejects both land
+//     in the store so later runs can dedup against them;
+//   - ideas are never written to Mio memory — CreativityStore only.
+
+const { IdeaGenerator } = require('@akemi-mio/creativity/IdeaGenerator')
+const { evaluateNovelty } = require('@akemi-mio/creativity/NoveltyScorer')
+
+// All > 0.7: IdeaGenerator.applyTemperature keeps such sources unconditionally
+// (temperature 0.5 middle branch) — deterministic prompt, no RNG survival.
+const WEIGHTS = { goal: 0.95, context: 0.9, constraint: 0.88, grounding: 0.75 }
+
+// `queryMemory` result → grounding sources + ids. Tolerates null/empty
+// (a thrown query is the caller's problem to catch; a miss is not).
+function groundingFrom(queryResult) {
+  const results = Array.isArray(queryResult && queryResult.results) ? queryResult.results : []
+  const sources = results.map((r) => ({
+    name: `${r.kind || 'memory'}: ${String(r.content || '').slice(0, 40)}`,
+    content: String(r.content || ''),
+    type: 'feedback',
+    weight: WEIGHTS.grounding,
+    origin: `memory:${r.id}`,
+    originId: r.id,
+    ...(r.timestamp ? { timestamp: r.timestamp } : {}),
+  }))
+  return { sources, relatedMemoryIds: results.map((r) => r.id), groundedWith: results.length }
+}
+
+function namedSource(role, text, origin, weight) {
+  const body = String(text).trim()
+  return {
+    name: `${role}: ${body.slice(0, 40)}`,
+    content: body,
+    type: 'knowledge',
+    weight,
+    origin,
+  }
+}
+
+async function runIdeaGenerate(options) {
+  const {
+    goal,
+    context = '',
+    constraints = [],
+    numIdeas,
+    chatJson,
+    store,
+    groundingSources = [],
+    relatedMemoryIds = [],
+    autoSources = [],
+  } = options || {}
+
+  const ordered = []
+  if (typeof goal === 'string' && goal.trim()) ordered.push(namedSource('goal', goal, 'goal', WEIGHTS.goal))
+  if (typeof context === 'string' && context.trim()) ordered.push(namedSource('context', context, 'context', WEIGHTS.context))
+  if (Array.isArray(constraints)) {
+    constraints.forEach((c, i) => {
+      if (typeof c === 'string' && c.trim()) ordered.push(namedSource('constraint', c, `constraint:${i}`, WEIGHTS.constraint))
+    })
+  }
+  for (const s of [...groundingSources, ...autoSources]) {
+    if (s && typeof s === 'object' && s.name) ordered.push(s)
+  }
+
+  const seen = new Set()
+  const sources = []
+  for (const s of ordered) {
+    const key = s.origin || s.name
+    if (seen.has(key)) continue
+    seen.add(key)
+    sources.push(s)
+  }
+
+  if (sources.length < 2) {
+    return { reason: 'need at least 2 sources — add --context/--constraints, or run `mio remember` first' }
+  }
+
+  const pairingStrategy = new Set(sources.map((s) => s.type)).size >= 2 ? 'explore' : 'stable'
+  const requested = Number(numIdeas)
+  const maxIdeas = Number.isFinite(requested) ? Math.min(Math.max(Math.trunc(requested), 1), 3) : 3
+
+  const rotationSeed = store.getHypotheses().length
+  const generator = new IdeaGenerator(chatJson, 0.5, undefined, rotationSeed)
+  // method left undefined: HypothesisGenerator rotates techniques internally
+  // from rotationSeed; the chosen one comes back on hypothesis.technique.
+  const creativeIdeas = await generator.generateIdeas(sources, maxIdeas, pairingStrategy, [])
+
+  const generatedAt = new Date().toISOString()
+  const recent = store.getHypotheses().slice(-30)
+  const rejected = store.getHypotheses({ status: 'rejected' }).slice(-50)
+
+  const ideas = []
+  const persistedIds = []
+  for (const { hypothesis: h, experiment } of creativeIdeas) {
+    const verdict = evaluateNovelty(h, recent, rejected)
+    if (verdict.shouldReject) {
+      h.status = 'rejected'
+      h.rejectionReason = verdict.rejectReason
+    } else {
+      h.novelty = verdict.adjustedNovelty
+    }
+    const labels = new Set(Array.isArray(h.sourceLabels) ? h.sourceLabels : [])
+    h.provenance = {
+      strategy: pairingStrategy,
+      technique: h.technique,
+      relatedMemoryIds: [...relatedMemoryIds],
+      sources: sources
+        .filter((s) => labels.has(s.name))
+        .map((s) => ({ name: s.name, type: s.type, origin: s.origin, timestamp: s.timestamp })),
+      generatedAt,
+    }
+    store.addHypothesis(h)
+    persistedIds.push(h.id)
+    ideas.push({ title: h.title, hypothesis: h, experiment, novelty: h.novelty, provenance: h.provenance })
+  }
+
+  return { ideas, generatedAt, groundedWith: groundingSources.length, persistedIds }
+}
+
+module.exports = { runIdeaGenerate, groundingFrom }

package/server/insight-store.js

@@ -52,10 +52,12 @@ function isInsightAvailable() {
   return Boolean(InsightStore)
 }
 
-// Score at or above which an unreported insight is counted as high-value in the
-// status summary.
-const INSIGHT_HIGH_VALUE_SCORE = 0.7
-const INSIGHT_HIGH_VALUE_LIMIT = 50
+// "High value" means score >= 50 (0-100 scale) AND confidence >= 0.7 (0-1).
+// These used to be named INSIGHT_HIGH_VALUE_SCORE = 0.7 / ..._LIMIT = 50 and
+// were passed in (LIMIT, SCORE) order -- correct only because the constants
+// happened to occupy each other's slots. Named for what they are now.
+const INSIGHT_HIGH_VALUE_SCORE_THRESHOLD = 50
+const INSIGHT_HIGH_VALUE_CONFIDENCE_THRESHOLD = 0.7
 
 function createInsightStore(options = {}) {
   const dataDir = options.dataDir
@@ -94,7 +96,10 @@ function createInsightStore(options = {}) {
       total: all.length,
       unreported: unreported.length,
       reported: all.length - unreported.length,
-      highValue: s.getHighValueUnreported(INSIGHT_HIGH_VALUE_LIMIT, INSIGHT_HIGH_VALUE_SCORE).length,
+      highValue: s.getHighValueUnreported(
+        INSIGHT_HIGH_VALUE_SCORE_THRESHOLD,
+        INSIGHT_HIGH_VALUE_CONFIDENCE_THRESHOLD,
+      ).length,
     }
   }
 
@@ -125,7 +130,11 @@ function createInsightStore(options = {}) {
         createdAt: m.createdAt || m.timestamp || Date.now(),
       })),
       summaries: args.summaries || [],
-      interactionCount: 0,
+      // 桌面端有真实交互流；CLI 默认没有。调用方可显式传入
+      // interactionCount/eventCount（如 MCP 侧按 trace 统计），
+      // 不传时 Scorer 会按记忆新鲜度给 confidence 兜底（旧逻辑
+      // 恒 0.2 会把 highValue 永久压成 0）。
+      interactionCount: Number(args.interactionCount) || 0,
       plans: (args.plans || []).map((p) => ({
         title: p.title || p.name || '',
         status: p.status || 'unknown',
@@ -133,13 +142,30 @@ function createInsightStore(options = {}) {
         steps: p.steps || [],
         createdAt: p.createdAt || Date.now(),
       })),
-      eventCount: 0,
+      eventCount: Number(args.eventCount) || 0,
     }
     const insights = await generator.generate(ctx)
     if (InsightStore && storePath) {
-      requireStore().addMany(insights)
+      // addMany is a pure push: every `mio insight generate` run used to
+      // append another copy of the same detection. Drop titles the store
+      // already holds (reported or not) so re-running is idempotent.
+      const s = requireStore()
+      const seen = new Set(s.getAll().map((i) => String(i.title || '').trim().toLowerCase()))
+      // Dedup against the store AND within the batch -- a generator that emits
+      // the same detection twice in one run must not survive just because the
+      // second copy was not there when the set was built.
+      const fresh = []
+      for (const i of insights || []) {
+        if (!i) continue
+        const key = i.title ? String(i.title).trim().toLowerCase() : null
+        if (key !== null && seen.has(key)) continue
+        if (key !== null) seen.add(key)
+        fresh.push(i)
+      }
+      if (fresh.length > 0) s.addMany(fresh)
+      return { generated: fresh.length, duplicates: (insights || []).length - fresh.length, insights: fresh }
     }
-    return { generated: insights.length, insights }
+    return { generated: (insights || []).length, insights }
   }
 
   return {
@@ -154,6 +180,6 @@ function createInsightStore(options = {}) {
 module.exports = {
   createInsightStore,
   isInsightAvailable,
-  INSIGHT_HIGH_VALUE_SCORE,
-  INSIGHT_HIGH_VALUE_LIMIT,
+  INSIGHT_HIGH_VALUE_SCORE_THRESHOLD,
+  INSIGHT_HIGH_VALUE_CONFIDENCE_THRESHOLD,
 }

package/server/llm-client.js

@@ -27,14 +27,13 @@ const path = require('path')
 const DEFAULT_API_URL = 'https://opencode.ai/zen/go/v1/chat/completions'
 const DEFAULT_MODEL = 'deepseek-v4-flash'
 
-// Resolve the directory holding config.json. The CLI and the MCP server use
-// different data dirs by design (MIO_HOME vs MIO_DATA_DIR||cwd/.mio-intelligence),
-// so we honour whichever is set and fall back to the CLI default. No third
-// convention is introduced here on purpose.
+// Resolve the directory holding config.json. The CLI uses MIO_HOME
+// (~/.mio-intelligence by default). The MCP server uses MIO_DATA_DIR ||
+// cwd/.mio-intelligence. This module serves the CLI-facing `llm-config`/
+// `config llm` commands, so we follow the CLI convention: MIO_HOME first.
 function homeDir() {
   return (
     process.env.MIO_HOME ||
-    process.env.MIO_DATA_DIR ||
     path.join(os.homedir(), '.mio-intelligence')
   )
 }
@@ -118,6 +117,13 @@ async function chatJson(userText, opts = {}) {
   const system = opts.system || 'You are a creative AI assistant. Output JSON.'
   const temperature = opts.temperature ?? 0.3
 
+  // response_format must match the prompt's top-level shape. Prompts that
+  // demand a top-level JSON array (InsightPrompt) can be rejected outright
+  // (HTTP 400) by OpenAI-compatible gateways that enforce json_object, so
+  // array callers omit the field and rely on prompt + fence-stripping parse.
+  const wantsArray = opts.responseFormat === 'array'
+  const responseFormat = wantsArray ? undefined : { type: 'json_object' }
+
   try {
     const resp = await fetch(apiUrl, {
       method: 'POST',
@@ -128,11 +134,12 @@ async function chatJson(userText, opts = {}) {
       body: JSON.stringify({
         model,
         temperature,
+        ...(opts.maxTokens ? { max_tokens: opts.maxTokens } : {}),
         messages: [
           { role: 'system', content: system },
           { role: 'user', content: userText },
         ],
-        response_format: { type: 'json_object' },
+        ...(responseFormat ? { response_format: responseFormat } : {}),
       }),
       signal: AbortSignal.timeout(opts.timeoutMs || 30000),
     })
@@ -140,10 +147,24 @@ async function chatJson(userText, opts = {}) {
     if (!resp.ok) return { error: `HTTP ${resp.status}` }
     const json = await resp.json()
     const text = json.choices?.[0]?.message?.content || ''
+
+    // Parse failures used to return { data: rawText }, so a prose answer
+    // masqueraded as a parsed object: callers testing truthy `result.data`
+    // stored an untitled, score-less record (and polluted the novelty
+    // dedup pool). A model that answered with anything but JSON is an
+    // error, not a degraded success. One retry with a code fence stripped
+    // covers models that wrap JSON despite response_format.
     try {
       return { data: JSON.parse(text) }
-    } catch {
-      return { data: text }
+    } catch (_) {}
+    const stripped = text.replace(/^\s*```(?:json)?\s*/i, '').replace(/\s*```\s*$/, '')
+    try {
+      return { data: JSON.parse(stripped) }
+    } catch (_) {
+      return {
+        error: 'model returned unparseable JSON',
+        raw: String(text).slice(0, 300),
+      }
     }
   } catch (err) {
     return { error: String(err) }