mio-agent-runtime 0.14.1 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -34,9 +34,9 @@
     "@akemi-mio/evolution-strategy": "^0.1.0",
     "@akemi-mio/evolution-safety": "^0.1.0",
     "@akemi-mio/evolution-scheduler": "^0.1.0",
-    "@akemi-mio/observer": "^0.1.4",
+    "@akemi-mio/observer": "^0.1.5",
     "@akemi-mio/insight": "^0.1.1",
-    "@akemi-mio/creativity": "^0.1.0"
+    "@akemi-mio/creativity": "^0.1.1"
   },
   "main": "index.js",
   "directories": {

package/server/creativity-engine.js

@@ -3,6 +3,7 @@
 const fs = require('fs')
 const path = require('path')
 const crypto = require('crypto')
+const { readJsonl } = require('./memory-store.js')
 const { evaluateNovelty } = require('@akemi-mio/creativity/NoveltyScorer')
 
 // Cache validity key for a JSONL file: a (size, mtimeMs) pair, the same
@@ -257,8 +258,55 @@ function listRow(h) {
   }
 }
 
+// --- read-side adoption join (idea b19bada4, design discussion 1d2e22e4 D3) ---
+// The store never gains an `adopted` status (D1/D4, see adoptHypothesis at the
+// bottom of this file): adoption is joined at READ time from the two evidence
+// axes the write side owns -- an append-only `creativity.adopt` trace event
+// (payload.hypothesisId = the CLAIM, written by mio.creativity.adopt) and a
+// `hypothesis:<id>` tag on a memory record (the EVIDENCE, injected by
+// mio.memory.record's hypothesisId parameter). The engine sits in
+// <dataRoot>/creativity on both hosts (MCP: path.join(dataDir, 'creativity');
+// CLI: path.join(MIO_HOME, 'creativity')), so the two evidence files are one
+// dirname up -- the same dataRoot convention adoptHypothesis documents.
+// Missing files are fine: readJsonl returns [] for them.
+//
+// The counts are informational joins, NOT ADR-017 metrics: no rate and no
+// threshold by design (D3 -- adoption rate was explicitly out of scope).
+// `sources` follows the routeAdoption pattern (evaluation-store.js): names
+// each axis' backing file and that it is durable, so a reader can tell
+// "0 adopted" apart from "evidence not kept". claimed/evidenced are raw
+// distinct ids (they can include ids no longer in the store); adopted is the
+// inner join against stored hypotheses, the only count that answers "which
+// surviving hypotheses were adopted".
+const ADOPTION_TAG_PREFIX = 'hypothesis:'
+
+const ADOPTION_SOURCES = Object.freeze({
+  events: { file: 'traces.jsonl', durable: true },
+  memory: { file: 'memory.jsonl', durable: true },
+})
+
+function readAdoptionEvidence(rootDir) {
+  const claimed = new Set()
+  for (const record of readJsonl(path.join(rootDir, 'traces.jsonl'))) {
+    if (!record || record.event_type !== 'creativity.adopt') continue
+    const id = record.payload && record.payload.hypothesisId
+    if (id) claimed.add(String(id))
+  }
+  const evidenced = new Set()
+  for (const record of readJsonl(path.join(rootDir, 'memory.jsonl'))) {
+    if (!record || !Array.isArray(record.tags)) continue
+    for (const tag of record.tags) {
+      if (typeof tag !== 'string' || !tag.startsWith(ADOPTION_TAG_PREFIX)) continue
+      const id = tag.slice(ADOPTION_TAG_PREFIX.length).trim()
+      if (id) evidenced.add(id)
+    }
+  }
+  return { claimed, evidenced }
+}
+
 class CreativityEngine {
   constructor(dataDir, chatJson) {
+    this.dataDir = dataDir
     this.store = new CreativityStore(dataDir)
     this.chatJson = chatJson
     this.strategyIndex = 0
@@ -510,6 +558,20 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
     return { fermented: results.length, results, errors }
   }
 
+  // Fresh per call: both evidence files are append-only and a long-lived MCP
+  // server must see new adopt events / memory tags without a restart (same
+  // rationale as the insight-store mtime cache -- minus the cache, since this
+  // is two small file reads on a read-only report path).
+  _adoption() {
+    const { claimed, evidenced } = readAdoptionEvidence(path.dirname(this.dataDir))
+    const storedIds = new Set(this.store.getHypotheses().map((h) => h.id))
+    const adoptedIds = new Set()
+    for (const id of [...claimed, ...evidenced]) {
+      if (storedIds.has(id)) adoptedIds.add(id)
+    }
+    return { claimed, evidenced, adoptedIds }
+  }
+
   status() {
     const count = this.store.count()
     const active = this.store.getHypotheses({ status: 'active' })
@@ -518,6 +580,7 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
     // draft is a real state -- ferment() reviews draft + active -- so hiding it
     // here made `status` and `list --status draft` disagree.
     const draft = this.store.getHypotheses({ status: 'draft' })
+    const adoption = this._adoption()
 
     return {
       ...count,
@@ -525,6 +588,19 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
       validated: validated.length,
       rejected: rejected.length,
       draft: draft.length,
+      // Derived join of the two evidence axes (see readAdoptionEvidence).
+      // metric:false is load-bearing: this is NOT an ADR-017 evaluation metric,
+      // so no rate and no threshold are reported -- adoption rate was explicitly
+      // out of scope (D3). sources names the backing files, routeAdoption style.
+      adoption: {
+        adopted: adoption.adoptedIds.size,
+        claimed: adoption.claimed.size,
+        evidenced: adoption.evidenced.size,
+        metric: false,
+        note:
+          'derived join of creativity.adopt events and hypothesis:<id> memory tags — informational; no rate or threshold by design',
+        sources: ADOPTION_SOURCES,
+      },
       recentIdeas: active.slice(-5).map(h => ({
         id: h.id,
         title: h.title,
@@ -544,6 +620,11 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
   // result. `limit: 0` (and only 0) opts back into "everything".
   list(opts = {}) {
     const limit = opts.limit === undefined ? 20 : opts.limit
+    // Same read-side join as status(): every row carries `adopted` so the two
+    // surfaces cannot disagree (the CLI/MCP entry points already share this
+    // engine). listRow() stays the pure store-row shape; decoration is here.
+    const adoption = this._adoption()
+    const decorate = (row) => ({ ...row, adopted: adoption.adoptedIds.has(row.id) })
     if (opts.sort === 'novelty') {
       // Relative novelty ranking (read-only, nothing written back). Pairwise
       // Jaccard is O(n²) — bound candidates to the newest 200 (spec Risk 3).
@@ -554,9 +635,13 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
         return { ...listRow(h), noveltyScore: verdict.adjustedNovelty }
       })
       rows.sort((a, b) => b.noveltyScore - a.noveltyScore || (b.createdAt || 0) - (a.createdAt || 0))
-      return limit === 0 ? rows : rows.slice(0, limit)
+      const decorated = rows.map(decorate)
+      return limit === 0 ? decorated : decorated.slice(0, limit)
     }
-    return this.store.getHypotheses({ status: opts.status, limit }).map(listRow)
+    return this.store
+      .getHypotheses({ status: opts.status, limit })
+      .map(listRow)
+      .map(decorate)
   }
 
   _buildGenerationPrompt(a, b, strategy, recentHypotheses, rejectedHypotheses) {
@@ -605,4 +690,69 @@ Output JSON with: title, idea, expectedBenefit, risk, novelty (0-100), feasibili
   }
 }
 
-module.exports = { CreativityEngine, CreativityStore, sourcesFromInsights, isoOf }
+// Adoption evidence (idea b19bada4, design discussion 1d2e22e4 D1/D4): the
+// store never gains an `adopted` status -- adoption is a relation between a
+// stored hypothesis and the outside world, not an attribute of the hypothesis,
+// so it lives as an append-only `creativity.adopt` trace event, optionally
+// cross-checked against a memory record carrying the `hypothesis:<id>` tag.
+// The host (MCP or CLI) passes its own ingestObservation so both entry points
+// write byte-identical events; dataRoot is the directory holding memory.jsonl
+// and traces.jsonl -- the engine sits in <dataRoot>/creativity on both hosts
+// (see cliCreativityEngine in bin/mio.js). Every validation failure happens
+// before ingest, so a rejected call never pollutes the event stream. This
+// function writes traces only: it never touches memory.jsonl (the
+// generate/ferment write nothing to Memory boundary extends here).
+function adoptHypothesis(engine, args = {}, ingest, dataRoot) {
+  const hypothesisId = String(args.hypothesisId || '').trim()
+  if (!hypothesisId) {
+    throw new Error('mio.creativity.adopt requires hypothesisId: a stored hypothesis UUID')
+  }
+  if (!engine.store.getHypotheses().some((h) => h.id === hypothesisId)) {
+    throw new Error(`mio.creativity.adopt: no stored hypothesis with id "${hypothesisId}"`)
+  }
+  const memoryId = String(args.memoryId || '').trim()
+  if (memoryId) {
+    const memoryPath = path.join(dataRoot, 'memory.jsonl')
+    const records = fs.existsSync(memoryPath)
+      ? fs
+          .readFileSync(memoryPath, 'utf-8')
+          .split('\n')
+          .filter(Boolean)
+          .map((line) => {
+            try { return JSON.parse(line) } catch { return null }
+          })
+          .filter(Boolean)
+      : []
+    const record = records.find((r) => r && r.id === memoryId)
+    if (!record) {
+      throw new Error(`mio.creativity.adopt: no memory record with id "${memoryId}"`)
+    }
+    const tag = `hypothesis:${hypothesisId}`
+    if (!Array.isArray(record.tags) || !record.tags.includes(tag)) {
+      throw new Error(`mio.creativity.adopt: memory record "${memoryId}" is missing tag "${tag}"`)
+    }
+  }
+  if (typeof ingest !== 'function') {
+    throw new Error('mio.creativity.adopt: ingest is not available on this host')
+  }
+  const taskId = String(args.taskId || '').trim()
+  const note = String(args.note || '').trim()
+  const result = ingest({
+    trace_id: `creativity-adopt:${hypothesisId}:${Date.now()}`,
+    event_type: 'creativity.adopt',
+    outcome: 'success',
+    payload: {
+      hypothesisId,
+      ...(memoryId ? { memoryId } : {}),
+      ...(taskId ? { taskId } : {}),
+      ...(note ? { note } : {}),
+    },
+  })
+  return {
+    recorded: true,
+    hypothesisId,
+    event: (result && result.event) || result,
+  }
+}
+
+module.exports = { CreativityEngine, CreativityStore, sourcesFromInsights, isoOf, adoptHypothesis }

package/server/mechanism-registry.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const path = require('path')
+
+// Re-export the pure TS helpers from the creativity package so CLI and MCP
+// share one implementation of the A5 gate, promotion gate, and state machine.
+// The JSONL store itself is the same MechanismRegistryStore the TS tests use.
+let _registry = null
+let _registryDir = null
+
+function ensureRegistry(dataDir) {
+  if (_registry && _registryDir === dataDir) return _registry
+  const { MechanismRegistryStore } = require('@akemi-mio/creativity/MechanismRegistry')
+  const base = path.join(dataDir, 'creativity')
+  _registry = new MechanismRegistryStore(path.join(base, 'mechanisms.jsonl'))
+  _registryDir = dataDir
+  return _registry
+}
+
+function resetRegistryCache() {
+  _registry = null
+  _registryDir = null
+}
+
+/**
+ * Query the mechanism registry: active/rolled_back versions and promotion requests.
+ */
+function mechanismRegistry(args = {}, dataDir) {
+  const registry = ensureRegistry(dataDir)
+  const mechanismId = args.mechanismId || undefined
+  const versions = mechanismId ? registry.listVersions(mechanismId) : registry.listVersions()
+  const requests = args.status ? registry.listRequests(args.status) : registry.listRequests()
+  return { versions, requests }
+}
+
+/**
+ * Submit a PromotionRequest. Gate is provided by the caller (checkSubmitGate).
+ * A5 is enforced inside MechanismRegistryStore.approve.
+ */
+function mechanismPromote(args = {}, dataDir) {
+  const registry = ensureRegistry(dataDir)
+  const action = args.action || 'submit'
+
+  if (action === 'submit') {
+    const { checkSubmitGate } = require('@akemi-mio/creativity/MechanismRegistry')
+    const { DEFAULT_STOPPING_RULE } = require('@akemi-mio/creativity/ExperimentRunStore')
+    // Build a minimal gate from provided experimentRunIds length; full gate
+    // wiring is in the TS layer. For CLI/MCP thin surface we accept an
+    // explicit gate override or compute from runs.length vs minSamples.
+    const runs = (args.experimentRunIds || []).map((id, i) => ({
+      id,
+      assignment: 'candidate',
+      outcome: 'success',
+      metrics: {},
+      evidenceIds: [],
+      createdAt: Date.now() - i,
+    }))
+    const gate = args.gateOverride
+      ? { allowed: !!args.gateOverride.allowed, reason: args.gateOverride.reason || 'ok' }
+      : checkSubmitGate(DEFAULT_STOPPING_RULE, runs, args.currentSnapshotId)
+    const result = registry.submit(
+      {
+        mechanismId: args.mechanismId,
+        version: args.version,
+        hypothesisId: args.hypothesisId,
+        experimentRunIds: args.experimentRunIds,
+        submittedBy: args.submittedBy,
+      },
+      gate,
+    )
+    return result
+  }
+
+  if (action === 'approve') {
+    return registry.approve(args.requestId, args.approvedBy)
+  }
+
+  if (action === 'reject') {
+    return registry.reject(args.requestId, args.approvedBy, args.reason || 'rejected')
+  }
+
+  return { ok: false, reason: 'unknown_action' }
+}
+
+/**
+ * Rollback the active version of a mechanism to its rollbackTo target.
+ */
+function mechanismRollback(args = {}, dataDir) {
+  const registry = ensureRegistry(dataDir)
+  return registry.rollback(args.mechanismId)
+}
+
+module.exports = {
+  mechanismRegistry,
+  mechanismPromote,
+  mechanismRollback,
+  ensureRegistry,
+  resetRegistryCache,
+}

package/server/memory-store.js

@@ -518,12 +518,23 @@ function createMemoryStore(options = {}) {
     const content = String(args.content || '').trim()
     if (!content) throw new Error('memory.record requires a non-empty content')
     const scope = normalizeScope(args.scope)
+    // Adoption evidence (idea b19bada4, task 2261a5f4): hypothesisId is pure
+    // sugar for the exact tag `mio.creativity.adopt` enforces — the record
+    // joins the creativity hypothesis through the same `hypothesis:<uuid>`
+    // tag the tags AND-filter already searches. Omitted, the record keeps
+    // the exact legacy shape: no extra field, tags byte-identical.
+    const hypothesisId = String(args.hypothesisId || '').trim()
+    const tags = normalizeTags(args.tags)
+    if (hypothesisId) {
+      const tag = `hypothesis:${hypothesisId}`
+      if (!tags.includes(tag)) tags.push(tag)
+    }
     const record = {
       id: createId('mem'),
       timestamp: new Date().toISOString(),
       kind: args.kind || 'note',
       content,
-      tags: normalizeTags(args.tags),
+      tags,
       project: scope === 'global' ? null : args.project || projectName(),
       scope,
       source: args.source || agentId() || 'mcp',