mio-agent-runtime 0.3.6 → 0.3.8

package/server/mio-intelligence-mcp/index.js

@@ -16,8 +16,13 @@ const dataDir = path.resolve(
 const memoryPath = path.join(dataDir, 'memory.jsonl')
 const tracePath = path.join(dataDir, 'traces.jsonl')
 const experienceReusePath = path.join(dataDir, 'experience_reuse.jsonl')
+const queryPath = path.join(dataDir, 'queries.jsonl')
+const subscriptionPath = path.join(dataDir, 'subscriptions.jsonl')
+const digestStatePath = path.join(dataDir, 'digest_state.json')
 fs.mkdirSync(dataDir, { recursive: true })
 
+const { loadPhase0, summarizePhase0, renderPhase0Markdown } = require('./phase0')
+
 let runtimeContext = {}
 try {
   const rawContext = process.env.MIO_CONTEXT
@@ -35,6 +40,44 @@ function runtimeAgentId() {
   return runtimeContext.agentId || null
 }
 
+// Phase 0 auto-claim: match memory.query results with a later task_outcome
+// from the same agent+project, so reuse evidence does not depend on the
+// agent self-reporting mio.experience.reuse.
+const REUSE_MATCH_WINDOW_MS = (() => {
+  const minutes = Number(process.env.MIO_REUSE_MATCH_WINDOW_MIN)
+  return Number.isFinite(minutes) && minutes > 0 ? minutes * 60 * 1000 : 60 * 60 * 1000
+})()
+const MAX_RECENT_QUERIES = 200
+let recentQueries = []
+
+function loadRecentQueries() {
+  const now = Date.now()
+  const entries = readJsonl(queryPath)
+    .filter(
+      (entry) =>
+        entry &&
+        typeof entry.agent === 'string' &&
+        entry.agent &&
+        typeof entry.expiresAt === 'number' &&
+        entry.expiresAt > now
+    )
+    .slice(-MAX_RECENT_QUERIES)
+  recentQueries = entries
+  return entries
+}
+
+function persistRecentQueries(entries) {
+  const limited = entries.slice(-MAX_RECENT_QUERIES)
+  fs.mkdirSync(dataDir, { recursive: true })
+  fs.writeFileSync(
+    queryPath,
+    limited.length > 0 ? limited.map((entry) => JSON.stringify(entry)).join('\n') + '\n' : '',
+    'utf8'
+  )
+  recentQueries = limited
+  return limited
+}
+
 function createId(prefix) {
   return `${prefix}_${Date.now()}_${crypto.randomBytes(6).toString('hex')}`
 }
@@ -43,6 +86,15 @@ function appendJsonl(file, value) {
   fs.appendFileSync(file, `${JSON.stringify(value)}\n`, 'utf8')
 }
 
+function writeJsonl(file, values) {
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(
+    file,
+    values.length > 0 ? values.map((value) => JSON.stringify(value)).join('\n') + '\n' : '',
+    'utf8'
+  )
+}
+
 function readJsonl(file) {
   if (!fs.existsSync(file)) return []
   return fs
@@ -115,36 +167,158 @@ function tokenize(text) {
   return [...latin, ...cjk]
 }
 
-function scoreRecord(record, queryTokens, project) {
+function normalizeScope(value) {
+  const s = String(value || 'project').trim().toLowerCase()
+  if (s === 'global' || s === 'all') return s
+  return 'project'
+}
+
+function isGlobalRecord(record) {
+  return String(record.scope || '').trim().toLowerCase() === 'global'
+}
+
+function matchesProjectScope(record, project, scope) {
+  const s = normalizeScope(scope)
+  if (s === 'global') return isGlobalRecord(record)
+  if (s === 'all') {
+    if (isGlobalRecord(record)) return true
+    return !project || record.project === project
+  }
+  // project (default): project-scoped records matching the project only
+  if (isGlobalRecord(record)) return false
+  return !project || record.project === project
+}
+
+function latinTokens(text) {
+  return String(text || '').toLowerCase().match(/[a-z0-9]+/g) || []
+}
+
+function cjkBigrams(text) {
+  const chars = String(text || '').toLowerCase().match(/[\u4e00-\u9fff]/g) || []
+  const bigrams = new Set()
+  for (let i = 0; i + 1 < chars.length; i += 1) {
+    bigrams.add(`${chars[i]}${chars[i + 1]}`)
+  }
+  return bigrams
+}
+
+function scoreRecord(record, queryText, project, evidence) {
   if (project && record.project && record.project !== project) return 0
-  const haystack = tokenize(
-    `${record.content || ''} ${(record.tags || []).join(' ')} ${record.kind || ''}`
-  )
+  const content = `${record.content || ''} ${(record.tags || []).join(' ')} ${record.kind || ''}`
+  const haystackTokens = tokenize(content)
+  const haystackLatin = latinTokens(content)
+  const queryTokens = tokenize(queryText)
   let score = 0
   for (const token of queryTokens) {
-    if (haystack.includes(token)) score += 1
+    if (haystackTokens.includes(token)) score += 2
+  }
+  const queryLatin = queryTokens.filter((token) => !token.startsWith('cjk:'))
+  for (const token of queryLatin) {
+    if (
+      token.length >= 3 &&
+      haystackLatin.some((item) => item.startsWith(token) || token.startsWith(item))
+    ) {
+      score += 1
+    }
   }
-  if (record.timestamp) {
+  const queryBigrams = cjkBigrams(queryText)
+  const haystackBigrams = cjkBigrams(content)
+  if (queryBigrams.size > 0 && haystackBigrams.size > 0) {
+    let matched = 0
+    for (const bigram of queryBigrams) {
+      if (haystackBigrams.has(bigram)) matched += 1
+    }
+    score += matched * 1.5
+  }
+  // Recency only boosts ranking among actual matches; it must not enable recall.
+  if (score > 0 && record.timestamp) {
     const ageDays = Math.max(0, (Date.now() - Date.parse(record.timestamp)) / 86400000)
     score += Math.max(0, 0.5 - ageDays * 0.05)
   }
+  // Evidence weighting (P2): memories successfully reused rank higher; never enables recall.
+  if (score > 0 && evidence && evidence.has(record.id)) {
+    const ev = evidence.get(record.id)
+    score += Math.min(2, ev.reuseCount * 0.6 + (ev.confirmedCount > 0 ? 1 : 0))
+  }
   return score
 }
 
+function matchesMemoryFilters(record, kind, tags) {
+  if (kind) {
+    const recordKind = String(record.kind || '').trim().toLowerCase()
+    if (recordKind !== kind) return false
+  }
+  if (tags.length > 0) {
+    const recordTags = new Set(
+      (record.tags || []).map((tag) => String(tag).trim().toLowerCase()),
+    )
+    for (const tag of tags) {
+      if (!recordTags.has(tag)) return false
+    }
+  }
+  return true
+}
+
 function queryMemory(args = {}) {
   const query = String(args.query || '')
   const project = args.project || projectName()
   const limit = Math.min(Math.max(Number(args.limit) || 5, 1), 20)
-  const tokens = tokenize(query)
+  const kind = args.kind ? String(args.kind).trim().toLowerCase() : null
+  const tags = Array.isArray(args.tags)
+    ? args.tags.map((tag) => String(tag).trim().toLowerCase()).filter(Boolean)
+    : []
+  const scope = normalizeScope(args.scope)
+  const evidence = loadEvidenceWeights()
+  const scoreFor = (record) =>
+    scoreRecord(record, query, project, evidence) +
+    (scope === 'all' && isGlobalRecord(record) ? 0.5 : 0)
   const results = readJsonl(memoryPath)
-    .filter((record) => scoreRecord(record, tokens, project) > 0)
+    .filter((record) => record.archived !== true)
+    .filter((record) => matchesMemoryFilters(record, kind, tags))
+    .filter((record) => matchesProjectScope(record, project, scope))
+    .filter((record) => scoreFor(record) > 0)
     .sort((a, b) => {
-      return scoreRecord(b, tokens, project) - scoreRecord(a, tokens, project)
+      return scoreFor(b) - scoreFor(a)
     })
     .slice(0, limit)
+    .map((record) => {
+      const ev = evidence.get(record.id)
+      if (!ev) return record
+      return {
+        ...record,
+        evidence: {
+          reuseCount: ev.reuseCount,
+          confirmedCount: ev.confirmedCount,
+          lastReusedAt: ev.lastReusedAt,
+        },
+      }
+    })
+  const layerCounts = { project: 0, global: 0 }
+  for (const record of results) {
+    if (record.scope === 'global' || !record.project) layerCounts.global += 1
+    else layerCounts.project += 1
+  }
+  if (results.length > 0) {
+    const timestamp = Date.now()
+    const entries = loadRecentQueries()
+    entries.push({
+      agent: runtimeAgentId() || 'mcp',
+      project,
+      query,
+      resultIds: results.map((record) => record.id).filter(Boolean),
+      resultSources: results.map((record) => record.source || null),
+      timestamp,
+      expiresAt: timestamp + REUSE_MATCH_WINDOW_MS,
+    })
+    persistRecentQueries(entries)
+  }
   return {
     query,
     project,
+    scope,
+    layers: layerCounts,
+    kind: kind || null,
+    tags: tags,
     count: results.length,
     results,
   }
@@ -153,13 +327,15 @@ function queryMemory(args = {}) {
 function recordMemory(args = {}) {
   const content = String(args.content || '').trim()
   if (!content) throw new Error('memory.record requires a non-empty content')
+  const scope = normalizeScope(args.scope)
   const record = {
     id: createId('mem'),
     timestamp: new Date().toISOString(),
     kind: args.kind || 'note',
     content,
     tags: normalizeTags(args.tags),
-    project: args.project || projectName(),
+    project: scope === 'global' ? null : args.project || projectName(),
+    scope,
     source: args.source || runtimeAgentId() || 'mcp',
   }
   appendJsonl(memoryPath, record)
@@ -183,9 +359,543 @@ function ingestObservation(args = {}) {
     project: args.project || projectName(),
   }
   appendJsonl(tracePath, event)
+  const autoClaims = autoClaimExperienceReuse(event)
+  if (autoClaims.length > 0) {
+    return { recorded: true, event, autoClaims }
+  }
   return { recorded: true, event }
 }
 
+function autoClaimExperienceReuse(event) {
+  if (String(event.event_type || '').toLowerCase() !== 'task_outcome') return []
+  const targetAgent = String(event.agent || '').trim()
+  if (!targetAgent) return []
+  const now = Date.now()
+  const claims = []
+  const remaining = []
+  const entries = loadRecentQueries()
+  for (const entry of entries) {
+    const expired = now - entry.timestamp > REUSE_MATCH_WINDOW_MS
+    const matches =
+      entry.agent === targetAgent && (!event.project || entry.project === event.project)
+    if (expired || matches) {
+      if (matches && !expired) {
+        claims.push(buildAutoClaim(entry, event, targetAgent))
+      }
+      continue
+    }
+    remaining.push(entry)
+  }
+  persistRecentQueries(remaining)
+  for (const evidence of claims) {
+    appendJsonl(experienceReusePath, evidence)
+  }
+  return claims
+}
+
+function buildAutoClaim(entry, event, targetAgent) {
+  const crossSourceIndex = entry.resultSources.findIndex(
+    (source) => source && String(source).toLowerCase() !== targetAgent.toLowerCase()
+  )
+  const sourceAgent =
+    crossSourceIndex >= 0
+      ? String(entry.resultSources[crossSourceIndex])
+      : targetAgent
+  const experienceId =
+    entry.resultIds[crossSourceIndex >= 0 ? crossSourceIndex : 0] ||
+    entry.resultIds[0] ||
+    'unknown'
+  const outcomeImproved = String(event.outcome || '').toLowerCase() === 'success'
+  return {
+    id: createId('xfer'),
+    timestamp: new Date().toISOString(),
+    sourceAgent,
+    targetAgent,
+    experienceId,
+    reuse: true,
+    behaviorChanged: false,
+    outcomeImproved,
+    project: entry.project,
+    source: 'auto_claim',
+    traceId: event.trace_id || null,
+    notes: `Auto-claimed: memory.query "${entry.query}" matched task_outcome ${event.outcome || 'unknown'} in trace ${event.trace_id || 'unknown'}.`,
+  }
+}
+
+const SUBSCRIPTION_DEFAULT_TTL_DAYS = 30
+const MAX_SUBSCRIPTIONS_PER_AGENT = 20
+const MAX_DIGEST_EVENTS = 100
+
+function readDigestState() {
+  if (!fs.existsSync(digestStatePath)) return {}
+  try {
+    const parsed = JSON.parse(fs.readFileSync(digestStatePath, 'utf8'))
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {}
+  } catch (_) {
+    return {}
+  }
+}
+
+function writeDigestState(state) {
+  fs.mkdirSync(dataDir, { recursive: true })
+  fs.writeFileSync(digestStatePath, JSON.stringify(state), 'utf8')
+}
+
+function subscribeKey(agent, project, eventTypes, topic) {
+  return `${agent}|${project}|${eventTypes.join(',')}|${topic || ''}`
+}
+
+function loadActiveSubscriptions(agent) {
+  const now = Date.now()
+  return readJsonl(subscriptionPath)
+    .filter((subscription) => subscription && subscription.agent === agent)
+    .filter((subscription) => {
+      if (subscription.expiresAt) {
+        const expires = new Date(subscription.expiresAt).getTime()
+        if (Number.isFinite(expires) && expires <= now) return false
+      }
+      return true
+    })
+}
+
+function subscribeObserver(args = {}) {
+  const agent = runtimeAgentId() || 'mcp'
+  const project = args.project || projectName()
+  const eventTypes = Array.isArray(args.eventTypes)
+    ? args.eventTypes.map((value) => String(value).trim().toLowerCase()).filter(Boolean)
+    : []
+  const topic = args.topic ? String(args.topic).trim().slice(0, 120) : ''
+  const ttlDays = Number(args.ttlDays) || SUBSCRIPTION_DEFAULT_TTL_DAYS
+  const ttlMs = Math.max(1, ttlDays) * 24 * 60 * 60 * 1000
+
+  const subscriptions = readJsonl(subscriptionPath)
+  const key = subscribeKey(agent, project, eventTypes, topic)
+  let existing = subscriptions.find((subscription) => {
+    return (
+      subscription &&
+      subscribeKey(
+        subscription.agent,
+        subscription.project,
+        subscription.eventTypes || [],
+        subscription.topic || '',
+      ) === key
+    )
+  })
+  const now = new Date()
+  const expiresAt = new Date(now.getTime() + ttlMs).toISOString()
+  if (existing) {
+    existing.updatedAt = now.toISOString()
+    existing.expiresAt = expiresAt
+  } else {
+    existing = {
+      id: createId('sub'),
+      agent,
+      project,
+      eventTypes,
+      topic: topic || null,
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      expiresAt,
+    }
+    subscriptions.push(existing)
+  }
+  const agentSubscriptions = subscriptions.filter((subscription) => subscription.agent === agent)
+  if (agentSubscriptions.length > MAX_SUBSCRIPTIONS_PER_AGENT) {
+    throw new Error(`Too many subscriptions for agent ${agent} (max ${MAX_SUBSCRIPTIONS_PER_AGENT})`)
+  }
+  writeJsonl(subscriptionPath, subscriptions)
+  return { subscribed: true, subscription: existing, project }
+}
+
+function observerDigest(args = {}) {
+  const agent = runtimeAgentId() || 'mcp'
+  const project = args.project || projectName()
+  const limit = Math.min(Math.max(Number(args.limit) || 20, 1), MAX_DIGEST_EVENTS)
+  const filterEventTypes = Array.isArray(args.eventTypes)
+    ? args.eventTypes.map((value) => String(value).trim().toLowerCase()).filter(Boolean)
+    : null
+
+  let subscriptions = loadActiveSubscriptions(agent)
+  if (args.project) {
+    subscriptions = subscriptions.filter((subscription) => subscription.project === project)
+  }
+  if (filterEventTypes) {
+    subscriptions = subscriptions.filter((subscription) => {
+      if ((subscription.eventTypes || []).length === 0) return true
+      return filterEventTypes.some((eventType) =>
+        (subscription.eventTypes || []).includes(eventType),
+      )
+    })
+  }
+
+  const state = readDigestState()
+  const traces = readJsonl(tracePath)
+  const digestTime = new Date().toISOString()
+  const events = []
+  const seenIds = new Set()
+  const matchedSubscriptionIds = new Set()
+
+  for (const subscription of subscriptions) {
+    const cursor = state[subscription.id] || null
+    const cursorTime = cursor ? Date.parse(cursor) : null
+    const subscriptionEventTypes = subscription.eventTypes || []
+    let lastEventTime = null
+    for (const event of traces) {
+      if (subscription.project && event.project && event.project !== subscription.project) {
+        continue
+      }
+      if (
+        subscriptionEventTypes.length > 0 &&
+        !subscriptionEventTypes.includes(String(event.event_type || '').toLowerCase())
+      ) {
+        continue
+      }
+      if (subscription.topic) {
+        const haystack = `${event.event_type || ''} ${JSON.stringify(event.payload || {})}`
+          .toLowerCase()
+        if (!haystack.includes(subscription.topic.toLowerCase())) continue
+      }
+      const eventTime = event.timestamp ? Date.parse(event.timestamp) : null
+      if (cursorTime !== null && eventTime !== null && eventTime <= cursorTime) continue
+      if (eventTime !== null && (lastEventTime === null || eventTime > lastEventTime)) {
+        lastEventTime = eventTime
+      }
+      if (seenIds.has(event.id)) continue
+      seenIds.add(event.id)
+      events.push({
+        id: event.id,
+        trace_id: event.trace_id || null,
+        event_type: event.event_type,
+        outcome: event.outcome || null,
+        timestamp: event.timestamp,
+        agent: event.agent || null,
+        payload: event.payload || null,
+      })
+      matchedSubscriptionIds.add(subscription.id)
+      if (events.length >= limit) break
+    }
+    if (lastEventTime !== null) {
+      state[subscription.id] = new Date(lastEventTime).toISOString()
+    } else if (cursor === null) {
+      state[subscription.id] = digestTime
+    }
+    if (events.length >= limit) break
+  }
+
+  writeDigestState(state)
+  return {
+    project,
+    agent,
+    subscriptionCount: subscriptions.length,
+    matchedSubscriptions: Array.from(matchedSubscriptionIds),
+    count: events.length,
+    events,
+  }
+}
+
+function contentTokens(value) {
+  const text = String(value || '').toLowerCase()
+  const latin = text.match(/[a-z0-9]+/g) || []
+  const chars = text.match(/[\u4e00-\u9fff]/g) || []
+  const bigrams = []
+  for (let i = 0; i < chars.length - 1; i++) {
+    bigrams.push(`${chars[i]}${chars[i + 1]}`)
+  }
+  return [...latin, ...bigrams]
+}
+
+function jaccardSimilarity(a, b) {
+  const setA = new Set(contentTokens(a))
+  const setB = new Set(contentTokens(b))
+  if (setA.size === 0 || setB.size === 0) return 0
+  let intersection = 0
+  for (const token of setA) {
+    if (setB.has(token)) intersection += 1
+  }
+  const union = setA.size + setB.size - intersection
+  return union === 0 ? 0 : intersection / union
+}
+
+function findDuplicateGroups(records, limit) {
+  const parent = new Map()
+  for (const record of records) parent.set(record.id, record.id)
+  const find = (id) => {
+    while (parent.get(id) !== id) {
+      parent.set(id, parent.get(parent.get(id)))
+      id = parent.get(id)
+    }
+    return id
+  }
+  const union = (a, b) => {
+    const ra = find(a)
+    const rb = find(b)
+    if (ra !== rb) parent.set(ra, rb)
+  }
+  for (let i = 0; i < records.length; i++) {
+    for (let j = i + 1; j < records.length; j++) {
+      if (
+        jaccardSimilarity(records[i].content, records[j].content) >= MEMORY_DUPLICATE_SIMILARITY
+      ) {
+        union(records[i].id, records[j].id)
+      }
+    }
+  }
+  const byRoot = new Map()
+  for (const record of records) {
+    const root = find(record.id)
+    if (!byRoot.has(root)) byRoot.set(root, [])
+    byRoot.get(root).push(record)
+  }
+  return Array.from(byRoot.values())
+    .filter((group) => group.length >= 2)
+    .sort((a, b) => b.length - a.length)
+    .slice(0, limit)
+}
+
+function analyzeMemory(args = {}) {
+  const project = args.project || projectName()
+  const limit = Math.min(Math.max(Number(args.limit) || 5, 1), 20)
+  const records = readJsonl(memoryPath).filter(
+    (record) => !project || record.project === project || !record.project,
+  )
+  const archived = records.filter((record) => record.archived === true).length
+  const activeRecords = records.filter((record) => record.archived !== true)
+  const total = activeRecords.length
+  const layerCounts = { project: 0, global: 0 }
+  for (const record of activeRecords) {
+    if (record.scope === 'global' || !record.project) layerCounts.global += 1
+    else layerCounts.project += 1
+  }
+
+  const byKind = {}
+  const lowQuality = []
+  for (const record of activeRecords) {
+    const kind = String(record.kind || '').trim() || 'unknown'
+    byKind[kind] = (byKind[kind] || 0) + 1
+    const content = String(record.content || '').trim()
+    const issues = []
+    if (!content) issues.push('missing content')
+    else if (content.length < MEMORY_SHORT_CONTENT_MIN) issues.push('content too short')
+    if (!record.kind || !String(record.kind).trim()) issues.push('missing kind')
+    if (issues.length > 0) {
+      lowQuality.push({
+        id: record.id,
+        timestamp: record.timestamp,
+        kind: record.kind || null,
+        content: content.slice(0, 200) || null,
+        issues,
+      })
+    }
+  }
+
+  let duplicateGroups = []
+  let duplicatesSkipped = false
+  if (activeRecords.length > MAX_PAIRWISE_MEMORY) {
+    duplicatesSkipped = true
+  } else {
+    duplicateGroups = findDuplicateGroups(activeRecords, limit).map((group) => ({
+      size: group.length,
+      records: group.map((record) => ({
+        id: record.id,
+        timestamp: record.timestamp,
+        kind: record.kind || null,
+        content: String(record.content || '').slice(0, 200),
+      })),
+    }))
+  }
+
+  const issues = {
+    lowQuality: lowQuality.length,
+    duplicateGroups: duplicateGroups.length,
+    duplicatesSkipped,
+  }
+
+  const suggestions = []
+  if (duplicateGroups.length > 0) {
+    suggestions.push(
+      `Found ${duplicateGroups.length} duplicate group(s); consider archiving or merging duplicates to keep recall precise.`,
+    )
+  }
+  if (lowQuality.length > 0) {
+    suggestions.push(
+      `${lowQuality.length} low-quality record(s) (missing kind/content or too short); consider fixing or removing them.`,
+    )
+  }
+  if (total === 0) {
+    suggestions.push('No memory records for this project yet.')
+  } else if (duplicateGroups.length === 0 && lowQuality.length === 0) {
+    suggestions.push('Memory looks healthy; no dedup or quality fixes needed.')
+  }
+
+  return {
+    project: project || null,
+    total,
+    archived,
+    layers: layerCounts,
+    byKind,
+    issues,
+    duplicates: duplicateGroups,
+    lowQuality: lowQuality.slice(0, limit),
+    suggestions,
+  }
+}
+
+function migrateMemory(args = {}) {
+  const idsInput = Array.isArray(args.ids) ? args.ids : []
+  const ids = idsInput.map((value) => String(value).trim()).filter(Boolean)
+  if (ids.length === 0) throw new Error('memory.migrate requires ids (array of memory record ids)')
+  const targetScope = normalizeScope(args.scope)
+  if (targetScope === 'all') throw new Error('memory.migrate scope must be project or global')
+  const project = args.project || projectName()
+  const reason = args.reason ? String(args.reason).trim().slice(0, 200) : null
+
+  const records = readJsonl(memoryPath)
+  const idSet = new Set(ids)
+  const updated = []
+  const unchanged = []
+  const notFound = [...ids]
+  for (const record of records) {
+    if (!idSet.has(record.id)) continue
+    const fromScope = record.scope || 'project'
+    const fromProject = record.project || null
+    if (fromScope === targetScope) {
+      unchanged.push(record.id)
+    } else {
+      record.scope = targetScope
+      record.project = targetScope === 'global' ? null : project
+      record.migratedAt = new Date().toISOString()
+      record.migratedFrom = fromScope === 'global' ? 'global' : fromProject || 'project'
+      if (reason) record.migrateReason = reason
+      updated.push(record.id)
+    }
+    const index = notFound.indexOf(record.id)
+    if (index >= 0) notFound.splice(index, 1)
+  }
+  writeJsonl(memoryPath, records)
+
+  return {
+    project: project || null,
+    scope: targetScope,
+    updated,
+    updatedCount: updated.length,
+    unchanged,
+    notFound,
+  }
+}
+function archiveMemory(args = {}) {
+  const idsInput = Array.isArray(args.ids) ? args.ids : []
+  const ids = idsInput.map((value) => String(value).trim()).filter(Boolean)
+  if (ids.length === 0) throw new Error('memory.archive requires ids (array of memory record ids)')
+  const project = args.project || projectName()
+  const restore = args.restore === true || args.restore === 'true'
+  const reason = args.reason ? String(args.reason).trim().slice(0, 200) : null
+
+  const records = readJsonl(memoryPath)
+  const idSet = new Set(ids)
+  const archived = []
+  const notFound = [...ids]
+  for (const record of records) {
+    if (!idSet.has(record.id)) continue
+    if (project && record.project && record.project !== project) continue
+    if (restore) {
+      if (record.archived === true) {
+        delete record.archived
+        delete record.archivedAt
+        delete record.archiveReason
+        archived.push(record.id)
+      }
+    } else if (record.archived !== true) {
+      record.archived = true
+      record.archivedAt = new Date().toISOString()
+      if (reason) record.archiveReason = reason
+      archived.push(record.id)
+    }
+    const index = notFound.indexOf(record.id)
+    if (index >= 0) notFound.splice(index, 1)
+  }
+  writeJsonl(memoryPath, records)
+
+  return {
+    project: project || null,
+    restored: restore,
+    archived,
+    archivedCount: archived.length,
+    notFound,
+  }
+}
+
+const FAILURE_OUTCOMES = new Set(['failure', 'error', 'aborted', 'retry'])
+const MEMORY_DUPLICATE_SIMILARITY = 0.75
+const MEMORY_SHORT_CONTENT_MIN = 20
+const MAX_PAIRWISE_MEMORY = 1500
+
+function isFailureOutcome(value) {
+  return FAILURE_OUTCOMES.has(String(value || '').toLowerCase())
+}
+
+function summarizeTrace(event) {
+  const payload = event.payload
+  if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+    if (typeof payload.summary === 'string' && payload.summary.trim()) {
+      return payload.summary.trim().slice(0, 160)
+    }
+    if (typeof payload.tool === 'string' && payload.tool.trim()) {
+      return `tool: ${payload.tool.trim().slice(0, 120)}`
+    }
+    if (typeof payload.error === 'string' && payload.error.trim()) {
+      return payload.error.trim().slice(0, 160)
+    }
+  }
+  return String(event.event_type || 'trace').slice(0, 120)
+}
+
+function buildPolicyGuidance({ total, failures, risk, failureExamples, relatedMemories }) {
+  const guidance = {
+    level: 'none',
+    rationale: null,
+    saferAlternatives: [],
+    verificationSteps: [],
+    avoid: [],
+    hardGate: false,
+  }
+  if (total === 0) {
+    guidance.rationale =
+      'No historical evidence for this action yet. Treat as normal risk and record the outcome.'
+    return guidance
+  }
+  const verifiedMemories = relatedMemories.filter((record) => record.evidence)
+  const hasVerified = verifiedMemories.length > 0
+  if (risk >= 0.4 && failures >= 2) {
+    guidance.level = hasVerified ? 'actionable' : 'advisory'
+    guidance.rationale =
+      'Repeated historical failures. Prefer an alternative approach and add rollback/verification.'
+    guidance.avoid = failureExamples
+      .map((example) => example.summary)
+      .filter(Boolean)
+      .slice(0, 3)
+  } else if (risk >= 0.2 || hasVerified) {
+    guidance.level = hasVerified ? 'actionable' : 'advisory'
+    guidance.rationale = hasVerified
+      ? 'Verified experience exists for this action; apply it before proceeding.'
+      : 'Moderate historical risk. Add verification before proceeding.'
+  } else {
+    guidance.level = 'advisory'
+    guidance.rationale = 'Low historical risk. Proceed with normal checks and record the outcome.'
+  }
+  if (hasVerified) {
+    guidance.saferAlternatives = verifiedMemories.slice(0, 3).map((record) => ({
+      memoryId: record.id,
+      reuseCount: record.evidence.reuseCount,
+      content: String(record.content || '').slice(0, 300),
+    }))
+  }
+  guidance.verificationSteps = [
+    'Add an explicit verification step after execution (dry-run, rollback plan, or assertion).',
+    'Record the outcome with mio.observer.ingest so the evidence base improves.',
+  ]
+  return guidance
+}
+
 function policyCheck(args = {}) {
   const action = String(args.action || '').trim()
   if (!action) throw new Error('policy.check requires action')
@@ -199,10 +909,26 @@ function policyCheck(args = {}) {
     return actionTokens.some((token) => haystack.includes(token))
   })
   const total = traces.length
-  const failures = traces.filter((event) =>
-    ['failure', 'error', 'aborted', 'retry'].includes(String(event.outcome || '').toLowerCase())
-  ).length
+  const failures = traces.filter((event) => isFailureOutcome(event.outcome)).length
   const risk = total > 0 ? failures / total : null
+  const riskLevel = total === 0 ? 'unknown' : risk >= 0.4 ? 'high' : risk >= 0.2 ? 'moderate' : 'low'
+  const outcomeCounts = traces.reduce((counts, event) => {
+    const outcome = String(event.outcome || 'unknown').toLowerCase() || 'unknown'
+    counts[outcome] = (counts[outcome] || 0) + 1
+    return counts
+  }, {})
+  const failureExamples = traces
+    .filter((event) => isFailureOutcome(event.outcome))
+    .sort((a, b) => new Date(b.timestamp || 0).getTime() - new Date(a.timestamp || 0).getTime())
+    .slice(0, 3)
+    .map((event) => ({
+      trace_id: event.trace_id || event.id || null,
+      event_type: event.event_type || null,
+      outcome: event.outcome || null,
+      timestamp: event.timestamp || null,
+      agent: event.agent || null,
+      summary: summarizeTrace(event),
+    }))
   let suggestion
   if (total === 0) {
     suggestion = 'No history for this action. Treat as normal risk and record the outcome.'
@@ -213,24 +939,41 @@ function policyCheck(args = {}) {
   } else {
     suggestion = 'Low historical risk. Proceed with normal checks.'
   }
+  const evidence = loadEvidenceWeights()
   const relatedMemories = readJsonl(memoryPath)
-    .filter((record) => scoreRecord(record, actionTokens, project) > 0)
-    .sort((a, b) => scoreRecord(b, actionTokens, project) - scoreRecord(a, actionTokens, project))
+    .filter((record) => scoreRecord(record, action, project, evidence) > 0)
+    .sort((a, b) => scoreRecord(b, action, project, evidence) - scoreRecord(a, action, project, evidence))
     .slice(0, 3)
-    .map((record) => ({
-      id: record.id,
-      timestamp: record.timestamp,
-      kind: record.kind,
-      content: record.content,
-      tags: record.tags,
-    }))
+    .map((record) => {
+      const ev = evidence.get(record.id)
+      return {
+        id: record.id,
+        timestamp: record.timestamp,
+        kind: record.kind,
+        content: record.content,
+        tags: record.tags,
+        evidence: ev
+          ? { reuseCount: ev.reuseCount, confirmedCount: ev.confirmedCount }
+          : null,
+      }
+    })
   return {
     action,
     project,
     total,
     failures,
     risk: risk === null ? null : Number(risk.toFixed(3)),
+    riskLevel,
+    outcomeCounts,
+    failureExamples,
     suggestion,
+    guidance: buildPolicyGuidance({
+      total,
+      failures,
+      risk,
+      failureExamples,
+      relatedMemories,
+    }),
     related_memories: relatedMemories,
   }
 }
@@ -243,6 +986,7 @@ function recordExperienceReuse(args = {}) {
   if (!targetAgent) throw new Error('experience.reuse requires targetAgent')
   if (!experienceId) throw new Error('experience.reuse requires experienceId')
 
+  const project = args.project || projectName()
   const evidence = {
     id: createId('xfer'),
     timestamp: new Date().toISOString(),
@@ -252,11 +996,279 @@ function recordExperienceReuse(args = {}) {
     reuse: args.reuse === true || args.reuse === 'true',
     behaviorChanged: args.behaviorChanged === true || args.behaviorChanged === 'true',
     outcomeImproved: args.outcomeImproved === true || args.outcomeImproved === 'true',
-    project: args.project || projectName(),
+    project,
+    source: args.source || 'agent_report',
     notes: args.notes || null,
   }
   appendJsonl(experienceReusePath, evidence)
-  return evidence
+
+  const report = loadPhase0(dataDir, project)
+  return {
+    recorded: true,
+    evidence,
+    phase0: summarizePhase0(report),
+  }
+}
+
+function confirmExperienceReuse(args = {}) {
+  const id = String(args.id || '').trim()
+  if (!id) throw new Error('experience.confirm requires id of an auto-claimed reuse record')
+  const records = readJsonl(experienceReusePath)
+  const index = records.findIndex((record) => record && record.id === id)
+  if (index < 0) {
+    throw new Error(`No experience reuse record found with id ${id}`)
+  }
+  const record = records[index]
+  if (record.source !== 'auto_claim') {
+    throw new Error('experience.confirm only applies to source=auto_claim reuse records')
+  }
+  const outcomeImproved =
+    args.outcomeImproved === undefined || args.outcomeImproved === null
+      ? record.outcomeImproved === true
+      : args.outcomeImproved === true || args.outcomeImproved === 'true'
+  const updated = {
+    ...record,
+    behaviorChanged: true,
+    outcomeImproved,
+    confirmed: true,
+    confirmedAt: new Date().toISOString(),
+    confirmedBy: String(args.confirmedBy || 'agent').trim() || 'agent',
+    notes: args.notes ? String(args.notes).trim() : record.notes || null,
+  }
+  records[index] = updated
+  writeJsonl(experienceReusePath, records)
+
+  const report = loadPhase0(dataDir, updated.project)
+  return {
+    confirmed: true,
+    evidence: updated,
+    phase0: summarizePhase0(report),
+  }
+}
+
+const REUSE_STATUS_FILTERS = Object.freeze({
+  pending: (record) => record.source === 'auto_claim' && record.confirmed !== true,
+  confirmed: (record) => record.confirmed === true,
+  verified: (record) =>
+    (record.reuse === true || record.reuse === 'true') &&
+    (record.behaviorChanged === true || record.behaviorChanged === 'true') &&
+    (record.outcomeImproved === true || record.outcomeImproved === 'true'),
+  auto_claim: (record) => record.source === 'auto_claim',
+  agent_report: (record) => record.source !== 'auto_claim',
+})
+
+function loadEvidenceWeights() {
+  const weights = new Map()
+  for (const record of readJsonl(experienceReusePath)) {
+    if (!REUSE_STATUS_FILTERS.verified(record)) continue
+    const id = record.experienceId
+    if (!id) continue
+    let entry = weights.get(id)
+    if (!entry) {
+      entry = { reuseCount: 0, confirmedCount: 0, lastReusedAt: null }
+      weights.set(id, entry)
+    }
+    entry.reuseCount += 1
+    if (record.confirmed === true) entry.confirmedCount += 1
+    if (!entry.lastReusedAt || new Date(record.timestamp || 0) > new Date(entry.lastReusedAt)) {
+      entry.lastReusedAt = record.timestamp || null
+    }
+  }
+  return weights
+}
+
+function listExperienceReuse(args = {}) {
+  const project = args.project || projectName()
+  const status = String(args.status || 'all').trim().toLowerCase()
+  const targetAgent = String(args.targetAgent || '').trim().toLowerCase()
+  const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 100)
+
+  let records = readJsonl(experienceReusePath)
+  if (project) records = records.filter((record) => record.project === project)
+  if (targetAgent) {
+    records = records.filter(
+      (record) => String(record.targetAgent || '').toLowerCase() === targetAgent,
+    )
+  }
+  const matcher = REUSE_STATUS_FILTERS[status]
+  if (matcher) records = records.filter(matcher)
+  records.sort((a, b) => {
+    const at = new Date(a.timestamp || 0).getTime()
+    const bt = new Date(b.timestamp || 0).getTime()
+    return bt - at
+  })
+
+  const visible = records.slice(0, limit).map((record) => ({
+    id: record.id,
+    source: record.source,
+    sourceAgent: record.sourceAgent,
+    targetAgent: record.targetAgent,
+    experienceId: record.experienceId,
+    reuse: record.reuse === true || record.reuse === 'true',
+    behaviorChanged: record.behaviorChanged === true || record.behaviorChanged === 'true',
+    outcomeImproved: record.outcomeImproved === true || record.outcomeImproved === 'true',
+    confirmed: record.confirmed === true,
+    confirmedBy: record.confirmedBy || null,
+    traceId: record.traceId || null,
+    timestamp: record.timestamp,
+    project: record.project,
+    notes:
+      typeof record.notes === 'string' && record.notes ? record.notes.slice(0, 300) : null,
+  }))
+
+  return {
+    project: project || null,
+    status,
+    count: visible.length,
+    total: records.length,
+    records: visible,
+  }
+}
+
+function routeTask(args = {}) {
+  const task = String(args.task || '').trim()
+  if (!task) throw new Error('task.route requires a non-empty task')
+  const project = args.project || projectName()
+  const scope = normalizeScope(args.scope)
+  const limit = Math.min(Math.max(Number(args.limit) || 5, 1), 10)
+
+  const memories = readJsonl(memoryPath).filter((record) => record.archived !== true)
+  const memoryById = new Map(memories.map((record) => [record.id, record]))
+  const evidence = loadEvidenceWeights()
+
+  // Match verified reuse experiences whose source memory is relevant to the task.
+  const routeByMemory = new Map()
+  for (const record of readJsonl(experienceReusePath)) {
+    if (!REUSE_STATUS_FILTERS.verified(record)) continue
+    const memory = memoryById.get(record.experienceId)
+    if (!memory || !matchesProjectScope(memory, project, scope)) continue
+    const score = scoreRecord(memory, task, project)
+    if (score <= 0) continue
+    let entry = routeByMemory.get(record.experienceId)
+    if (!entry) {
+      entry = {
+        experienceId: record.experienceId,
+        memory,
+        weight: 0,
+        confirmed: false,
+        sourceAgents: new Set(),
+        targetAgents: new Set(),
+        reuseCount: 0,
+      }
+      routeByMemory.set(record.experienceId, entry)
+    }
+    entry.reuseCount += 1
+    if (record.confirmed === true) entry.confirmed = true
+    if (record.sourceAgent) entry.sourceAgents.add(record.sourceAgent)
+    if (record.targetAgent) entry.targetAgents.add(record.targetAgent)
+    entry.weight = Math.max(entry.weight, score + (entry.confirmed ? 2 : 1.5))
+  }
+
+  const routes = [...routeByMemory.values()]
+    .sort((a, b) => b.weight - a.weight)
+    .slice(0, limit)
+    .map((entry) => ({
+      experienceId: entry.experienceId,
+      reuseCount: entry.reuseCount,
+      confirmed: entry.confirmed,
+      sourceAgents: [...entry.sourceAgents].filter(Boolean),
+      targetAgents: [...entry.targetAgents].filter(Boolean),
+      score: Number(entry.weight.toFixed(2)),
+      memory: {
+        id: entry.memory.id,
+        timestamp: entry.memory.timestamp,
+        kind: entry.memory.kind,
+        content: entry.memory.content,
+        tags: entry.memory.tags || [],
+        project: entry.memory.project || null,
+        scope: entry.memory.scope || 'project',
+      },
+    }))
+
+  // Broader context: top related memories not already routed.
+  const routedIds = new Set(routes.map((route) => route.experienceId))
+  const scoreRelated = (record) =>
+    scoreRecord(record, task, project, evidence) +
+    (scope === 'all' && isGlobalRecord(record) ? 0.5 : 0)
+  const relatedMemories = memories
+    .filter((record) => !routedIds.has(record.id))
+    .filter((record) => matchesProjectScope(record, project, scope))
+    .filter((record) => scoreRelated(record) > 0)
+    .sort((a, b) => scoreRelated(b) - scoreRelated(a))
+    .slice(0, Math.max(limit, 5))
+    .map((record) => {
+      const ev = evidence.get(record.id)
+      return {
+        id: record.id,
+        timestamp: record.timestamp,
+        kind: record.kind,
+        content: record.content,
+        tags: record.tags || [],
+        project: record.project || null,
+        scope: record.scope || 'project',
+        evidence: ev
+          ? { reuseCount: ev.reuseCount, confirmedCount: ev.confirmedCount }
+          : null,
+      }
+    })
+
+  // Feed the query log so a later task_outcome can auto-claim route-driven reuse.
+  if (routes.length > 0 || relatedMemories.length > 0) {
+    const now = Date.now()
+    const entries = loadRecentQueries()
+    entries.push({
+      agent: runtimeAgentId() || 'mcp',
+      project,
+      query: task,
+      resultIds: [...routedIds, ...relatedMemories.map((record) => record.id)].filter(Boolean),
+      resultSources: [...routes.map(() => 'experience'), ...relatedMemories.map((record) => record.source || null)],
+      timestamp: now,
+      expiresAt: now + REUSE_MATCH_WINDOW_MS,
+    })
+    persistRecentQueries(entries)
+  }
+
+  let suggestion
+  if (routes.length > 0) {
+    suggestion =
+      `Route ${routes.length} verified experience(s) to this task; apply the top match first and record the outcome with mio.observer.ingest / mio.experience.reuse.`
+  } else if (relatedMemories.length > 0) {
+    suggestion =
+      'No verified experience matches yet. Consult the related memories, then record the outcome so this task can seed future routes.'
+  } else {
+    suggestion =
+      'No matching experience or memory found. Proceed with care and record the outcome to grow the experience base.'
+  }
+
+  return {
+    task,
+    project,
+    scope,
+    count: routes.length,
+    routes,
+    relatedMemories,
+    summary: {
+      verifiedRoutes: routes.length,
+      relatedMemories: relatedMemories.length,
+      suggestion,
+    },
+  }
+}
+function phase0Report(args = {}) {
+  const project = args.project || projectName()
+  const report = loadPhase0(dataDir, project)
+  const format = String(args.format || 'json').trim().toLowerCase()
+  if (format === 'markdown') {
+    return {
+      project,
+      format: 'markdown',
+      markdown: renderPhase0Markdown(report),
+    }
+  }
+  return {
+    project,
+    ...report,
+  }
 }
 
 const TOOLS = [
@@ -269,10 +1281,41 @@ const TOOLS = [
         query: { type: 'string', description: 'Question or topic to recall.' },
         project: { type: 'string', description: 'Project name filter. Defaults to current directory name.' },
         limit: { type: 'number', description: 'Maximum results, between 1 and 20. Defaults to 5.' },
+        kind: { type: 'string', description: 'Only return records with this kind (decision, context, problem, note).' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Only return records containing all of these tags (AND).' },
+        scope: { type: 'string', description: 'Search scope: project (default), global, or all.' },
       },
       required: ['query'],
     },
   },
+  {
+    name: 'mio.memory.archive',
+    description: 'Archive (or restore) memory records by id. Archived records are excluded from memory.query and memory.analyze.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'string' }, description: 'Memory record ids to archive or restore.' },
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        restore: { type: 'boolean', description: 'When true, un-archive the given ids instead.' },
+        reason: { type: 'string', description: 'Optional archive reason.' },
+      },
+      required: ['ids'],
+    },
+  },
+  {
+    name: 'mio.memory.migrate',
+    description: 'Migrate memory records between project and global layers (P3). Moving to global makes the record reusable across projects (project set to null); moving to project restores project scoping.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'string' }, description: 'Memory record ids to migrate.' },
+        scope: { type: 'string', description: 'Target layer: global or project.' },
+        project: { type: 'string', description: 'Target project for project scope. Defaults to current repository.' },
+        reason: { type: 'string', description: 'Optional migration reason.' },
+      },
+      required: ['ids', 'scope'],
+    },
+  },
   {
     name: 'mio.memory.record',
     description: 'Record a decision, project context, or historical problem into local Mio memory.',
@@ -283,6 +1326,7 @@ const TOOLS = [
         kind: { type: 'string', description: 'Memory kind, such as decision, context, or problem.' },
         tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags.' },
         project: { type: 'string', description: 'Project name. Defaults to current directory name.' },
+        scope: { type: 'string', description: 'Record scope: project (default) or global.' },
         source: { type: 'string', description: 'Recording source. Defaults to mcp.' },
       },
       required: ['content'],
@@ -305,9 +1349,34 @@ const TOOLS = [
       required: ['trace_id', 'event_type'],
     },
   },
+  {
+    name: 'mio.observer.subscribe',
+    description: 'Subscribe to observer events (project, event types, optional topic). New matching events are delivered via mio.observer.digest.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        eventTypes: { type: 'array', items: { type: 'string' }, description: 'Event types to watch, e.g. error, retry, task_outcome. Empty means all.' },
+        project: { type: 'string', description: 'Project name. Defaults to current repository.' },
+        topic: { type: 'string', description: 'Optional keyword; only events whose payload mentions it match.' },
+        ttlDays: { type: 'number', description: 'Subscription lifetime in days. Defaults to 30.' },
+      },
+    },
+  },
+  {
+    name: 'mio.observer.digest',
+    description: 'Return new observer events matching active subscriptions since the last digest, and advance the cursor.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        eventTypes: { type: 'array', items: { type: 'string' }, description: 'Optional extra event type filter.' },
+        limit: { type: 'number', description: 'Maximum events to return, 1-100. Defaults to 20.' },
+      },
+    },
+  },
   {
     name: 'mio.policy.check',
-    description: 'Check historical risk for an action before executing it.',
+    description: 'Check historical risk for an action before executing it, returning risk level, outcome counts, and recent failure examples.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -318,6 +1387,17 @@ const TOOLS = [
       required: ['action'],
     },
   },
+  {
+    name: 'mio.memory.analyze',
+    description: 'Analyze local Mio memory quality: kind distribution, duplicate groups, and low-quality records.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        limit: { type: 'number', description: 'Maximum duplicates/low-quality examples to return, 1-20. Defaults to 5.' },
+      },
+    },
+  },
   {
     name: 'mio.experience.reuse',
     description: 'Record Phase 0 evidence of cross-agent experience reuse.',
@@ -336,6 +1416,58 @@ const TOOLS = [
       required: ['sourceAgent', 'targetAgent', 'experienceId', 'reuse', 'behaviorChanged', 'outcomeImproved'],
     },
   },
+  {
+    name: 'mio.experience.confirm',
+    description: 'Confirm an auto-claimed reuse record as verified reuse evidence.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Id of the auto-claimed reuse record returned by mio.observer.ingest.' },
+        confirmedBy: { type: 'string', description: 'Who confirmed the reuse: agent or human. Defaults to agent.' },
+        outcomeImproved: { type: 'boolean', description: 'Override: true when the reused experience improved the task outcome. Defaults to the auto-claim value.' },
+        notes: { type: 'string', description: 'Optional confirmation notes.' },
+      },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'mio.experience.list',
+    description: 'List Phase 0 experience reuse evidence, optionally filtered by status or target agent.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        status: { type: 'string', description: 'Filter: pending (auto-claim awaiting confirmation), confirmed, verified, auto_claim, agent_report, all. Defaults to all.' },
+        targetAgent: { type: 'string', description: 'Filter records by target agent.' },
+        limit: { type: 'number', description: 'Maximum records to return, 1-100. Defaults to 20.' },
+      },
+    },
+  },
+  {
+    name: 'mio.phase0.report',
+    description: 'Generate the current Phase 0 cross-agent validation report, as JSON or rendered Markdown.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        format: { type: 'string', description: 'Output format: json or markdown. Defaults to json.' },
+      },
+    },
+  },
+  {
+    name: 'mio.task.route',
+    description: 'Route an incoming task to the most relevant verified experiences and related memories, turning recall into decision influence (P1).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task: { type: 'string', description: 'Task description to route, e.g. \'fix IPC communication bug\'.' },
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        scope: { type: 'string', description: 'Search scope: project (default), global, or all.' },
+        limit: { type: 'number', description: 'Maximum routes, between 1 and 10. Defaults to 5.' },
+      },
+      required: ['task'],
+    },
+  },
 ]
 
 async function callTool(name, args = {}) {
@@ -344,12 +1476,30 @@ async function callTool(name, args = {}) {
       return queryMemory(args)
     case 'mio.memory.record':
       return recordMemory(args)
+    case 'mio.memory.archive':
+      return archiveMemory(args)
+    case 'mio.memory.migrate':
+      return migrateMemory(args)
     case 'mio.observer.ingest':
       return ingestObservation(args)
+    case 'mio.observer.subscribe':
+      return subscribeObserver(args)
+    case 'mio.observer.digest':
+      return observerDigest(args)
     case 'mio.policy.check':
       return policyCheck(args)
+    case 'mio.memory.analyze':
+      return analyzeMemory(args)
     case 'mio.experience.reuse':
       return recordExperienceReuse(args)
+    case 'mio.experience.confirm':
+      return confirmExperienceReuse(args)
+    case 'mio.experience.list':
+      return listExperienceReuse(args)
+    case 'mio.phase0.report':
+      return phase0Report(args)
+    case 'mio.task.route':
+      return routeTask(args)
     default:
       throw new Error(`Unknown tool: ${name}`)
   }
@@ -426,7 +1576,9 @@ rl.on('line', (line) => {
 })
 
 rl.on('close', () => {
-  process.exit(0)
+  if (require.main === module) {
+    process.exit(0)
+  }
 })
 
-module.exports = { TOOLS, callTool, handleMessage, readJsonl, appendJsonl }
+module.exports = { TOOLS, callTool, handleMessage, readJsonl, appendJsonl, rl }