Eve library

phase-97.md

Tracker

Revision 1

On this page

Historical task source. The Eve task board holds current task state.

Phase 97: Skills System — Unified Skill Framework, Autonomous Generation & Cross-Domain Composition#

Build an industry-leading, SOTA skill system that unifies the 30+ independent skill-like systems across the Oshun ecosystem into a single framework with autonomous skill generation, self-evolution, cross-domain composition, quality tracking, MCP integration, and skill-specific model training. Integrates patterns from VOYAGER, Memento-Skills, OpenSpace, SkillX, MCP-Zero, xLAM, and the Agent Skills Open Standard.


97.1 Unified Skill Framework#

97.1.1 Canonical Skill Schema & Registry#

  • 97.1.1.1 Design canonical UniversalSkill schema: {skillId, name, domain, category, description, version, parameters (typed with Zod), returns (typed), handler (async function), timeoutMs, retryPolicy, qualityMetrics[], dependencies[], conflicts[], requiredPermissions[], sandboxLevel, executionHistory[], qualityScore, learningRate, breakingChanges[], minModelVersion, tags[]}
  • 97.1.1.2 Implement skill registry service backed by PostgreSQL with full CRUD, semantic search (pgvector on description embeddings), filter by domain/category/capability, and discovery API
  • 97.1.1.3 Build skill discovery engine with progressive disclosure (metadata always loaded ~100 tokens, full instructions loaded on activation, resources loaded on demand — following Agent Skills Open Standard pattern)
  • 97.1.1.4 Implement skill versioning with semver (major.minor.patch), immutable version snapshots, changelog tracking, breaking change detection, automatic compatibility checking between skill versions
  • 97.1.1.5 Build skill dependency resolver that automatically satisfies prerequisites (if skill B requires skill A's output, ensure A runs first), detect circular dependencies, and compose dependency DAGs
  • 97.1.1.6 Implement skill access control with RBAC (who can create/edit/execute/delete skills per domain), audit logging of all skill operations, and enterprise skill governance workflows (draft → review → approved → published)
  • 97.1.1.7 Build SKILL.md file format support conforming to Agent Skills Open Standard (YAML frontmatter + Markdown body + optional scripts/ + references/ + assets/ directories) for interoperability with Claude Code, Codex CLI, Cursor, GitHub Copilot, Gemini CLI, and 10+ other tools
  • 97.1.1.8 Implement skill tagging and categorization taxonomy: domain (iris, psyche, isis, maya, etc.), modality (text, image, audio, video, 3d, code), complexity (atomic, composed, workflow), interaction (sync, async, streaming), safety (safe, caution, dangerous, blocked)

97.1.2 Skill Execution Runtime#

  • 97.1.2.1 Build skill execution engine with sandboxed runtime (process-level isolation per skill execution), timeout enforcement, resource limits (memory, CPU, network), and graceful cancellation
  • 97.1.2.2 Implement skill execution telemetry: per-execution capture of {skillId, version, inputHash, outputHash, durationMs, tokensUsed, cost, success/failure, errorType, retryCount, callerContext} — feeding into data flywheel (Phase 85)
  • 97.1.2.3 Build skill retry and fallback system (configurable retry policies per skill: exponential backoff, circuit breaker, fallback to alternative skill, graceful degradation)
  • 97.1.2.4 Implement skill caching layer (cache skill outputs by input hash for idempotent skills, configurable TTL, cache invalidation on skill version update)
  • 97.1.2.5 Build skill rate limiting and quota management (per-user, per-domain, per-skill rate limits, burst allowances, quota tracking with alerts)

97.2 Cross-Domain Skill Composition#

97.2.1 Composition Engine#

  • 97.2.1.1 Build skill composition engine supporting: sequential chains (A → B → C), parallel execution (A | B | C → merge), conditional branching (if X then A else B), loops (repeat A until condition), and map/reduce (apply A to each item in collection)
  • 97.2.1.2 Implement cross-domain skill pipelines: enable composing skills from different domains (e.g., "research topic (Sophia) → generate illustration (Isis) → verify safety (Nous) → add to lesson (Metis) → publish (Yemaya)") with typed input/output contracts between steps
  • 97.2.1.3 Build skill pipeline definition language (YAML/JSON) with: step definitions, input/output mappings, error handlers, timeout per step, retry per step, conditional logic, parallel groups, and variable interpolation
  • 97.2.1.4 Implement pipeline visualization as interactive DAG (nodes = skills, edges = data flow, colors = domain, status indicators for running/complete/failed)
  • 97.2.1.5 Build pipeline template library with pre-composed cross-domain workflows for common tasks: content creation pipeline, research-to-publication pipeline, game asset pipeline, educational content pipeline, news production pipeline
  • 97.2.1.6 Implement SkillX-style three-tiered skill hierarchy: planning skills (high-level task organization), functional skills (reusable tool-based subroutines), atomic skills (execution-oriented patterns) — with automatic tier classification based on skill complexity and composition depth
  • 97.2.1.7 Build ReAcTree-style hierarchical agent tree execution: complex tasks decomposed into subgoals within a dynamically constructed agent tree with control flow nodes (sequential, parallel, conditional) and agent nodes (reason, act, expand into further subgoals)

97.2.2 Inter-Domain Skill Bridge#

  • 97.2.2.1 Build domain skill adapters that expose each domain's internal skill system through the unified interface: Iris tools → UniversalSkill, Maya abilities → UniversalSkill, Nous training methods → UniversalSkill, etc. for all 30+ existing systems
  • 97.2.2.2 Implement skill translation layer that converts between domain-specific skill formats and the canonical schema (preserving domain-specific metadata while enabling cross-domain discovery)
  • 97.2.2.3 Build cross-domain skill catalog that indexes all skills from all domains with unified search, showing which skills can interoperate and suggesting composition opportunities
  • 97.2.2.4 Implement skill transfer learning detector: identify when a skill pattern learned in one domain could benefit another (e.g., Maya combat balance tuning patterns could inform Euterpe music mixing balance)

97.3 Autonomous Skill Generation & Growth#

97.3.1 Skill Auto-Generation from Documentation#

  • 97.3.1.1 Build OpenAPI-to-skill auto-generator: parse all internal OpenAPI/Swagger specs across Oshun services → generate typed skill definitions with parameter schemas, return types, error handling, and usage examples (following Gorilla/ToolFactory pattern, with aggressive pruning per Stainless recommendations)
  • 97.3.1.2 Build documentation-to-skill pipeline: parse README.md, API docs, JSDoc/TSDoc comments → extract capability descriptions → generate SKILL.md files with instructions, parameter definitions, and example invocations
  • 97.3.1.3 Build code-to-skill extractor: analyze exported functions/classes across all domains → identify skill-worthy operations (public, documented, side-effect-free or safely sandboxed) → generate skill wrappers automatically
  • 97.3.1.4 Build database-schema-to-skill generator: parse Prisma/Drizzle schemas → generate CRUD skills for each entity with validation, access control, and audit logging
  • 97.3.1.5 Docstring-driven skill invocation (NexusRaven-style). Split 2026-09-18.
    • 97.3.1.5.a Build the runtime in libs/oshun/skill-system/src/discovery.ts: extract a tool schema (name, params, types) from each skill's TypeScript/Python docstring and signature, and let the assistant model (OpenRouter deepseek/deepseek-v4-flash-0731) invoke skills from those schemas with no per-skill glue. Verify: a spec registers three skills by docstring, asks the model to invoke one, and asserts the right skill runs with the parsed arguments.
    • 97.3.1.5.b Train a specialized function-calling model on docstring→call data. Needs an owner decision on a compute and data budget (stated 2026-09-18). blocked:governance
  • 97.3.1.6 Build CREATOR-style LLM tool creation: when no existing skill matches a task, LLM generates both the skill code and its SKILL.md documentation, verifies via execution, then stores in the skill library

97.3.2 VOYAGER-Pattern Autonomous Skill Library Growth#

  • 97.3.2.1 Build VOYAGER-style automatic curriculum that proposes increasingly complex tasks based on current skill library coverage and known capability gaps
  • 97.3.2.2 Implement skill code generation + verification loop: LLM generates skill implementation → execute in sandbox → capture results and errors → feed back to LLM for refinement → repeat until self-verification confirms success → commit to library
  • 97.3.2.3 Build skill library indexing via description embeddings (store each skill's natural language description as vector → retrieve top-k similar skills when facing new task → compose retrieved skills into solution)
  • 97.3.2.4 Implement skill deduplication via semantic similarity (when new skill's description embedding is within threshold of existing skill, compare execution behavior → merge, override, or keep both with differentiating tags)
  • 97.3.2.5 Build compositional skill creation: when existing atomic skills can be combined to solve a new task, automatically generate a composed skill that imports and chains them (skills as composable subroutines)
  • 97.3.2.6 Implement Memento-Skills pattern: skills stored as structured markdown files serving as persistent, evolving memory — start with minimal seed skills and grow organically from execution experience, with domain clusters forming autonomously

97.3.3 Self-Evolving Skill System#

  • 97.3.3.1 Build OpenSpace-style self-evolving skill engine with three evolution modes: FIX (repair broken skills from error logs), DERIVED (create enhanced/specialized versions from successful executions), CAPTURED (extract novel patterns from successful action sequences and codify as new skills)
  • 97.3.3.2 Implement evolution cycle: intercept task executions via hooks → log inputs/outputs to skill execution store → run diff analysis on failures and success metrics → trigger git-like commits to skill files → safety: confirmation gates, anti-loop guards, validation before replacement
  • 97.3.3.3 Active tool discovery (MCP-Zero-style). Split 2026-09-18.
    • 97.3.3.3.a Build the discovery runtime in libs/oshun/skill-system/src/mcp.ts: from a structured tool request (capability, inputs, constraints), route hierarchically over the skill registry by semantic match and return ranked candidates. Verify: a spec issues three requests against a fixture registry and asserts the top match and that an impossible request returns none.
    • 97.3.3.3.b Train the request-generation policy via RL. Needs an owner decision on a compute and data budget (stated 2026-09-18). blocked:governance
  • 97.3.3.4 Implement skill quality feedback loop: execution telemetry (97.1.2.2) feeds into skill quality scores → low-quality skills flagged for evolution → FIX mode attempts repair → if repair fails, skill deprecated and alternatives promoted
  • 97.3.3.5 Build ALAS-style skill mastery tracking: per-skill accuracy tracking across execution history → when accuracy drops below threshold, trigger skill refinement cycle → converge when all skills exceed mastery threshold
  • 97.3.3.6 Implement network-effect skill sharing: when one domain evolves a skill improvement, propagate the improvement to all domains using equivalent skills (collective intelligence pattern from OpenSpace)

97.4 MCP Skill Ecosystem#

97.4.1 MCP Server Infrastructure#

  • 97.4.1.1 Build MCP server generator that auto-creates an MCP server for each Oshun domain, exposing domain capabilities as MCP tools with typed schemas, resource endpoints, and prompt templates
  • 97.4.1.2 Implement MCP server for Iris: expose conversation tools (start, message, branch, summarize), agent tools (search, analyze, generate), memory tools (store, retrieve, forget), knowledge tools (query, cite, verify)
  • 97.4.1.3 Implement MCP server for Isis: expose generation tools (text-to-image, image-to-image, text-to-video, text-to-3d, text-to-audio), workflow tools (create, execute, monitor), quality tools (evaluate, compare, benchmark)
  • 97.4.1.4 Implement MCP server for Sophia: expose search tools (semantic, keyword, hybrid), knowledge tools (entity extract, relation extract, graph query), evaluation tools (RAG eval, citation verify)
  • 97.4.1.5 Implement MCP server for Maya: expose world tools (create zone, spawn NPC, modify terrain), game tools (grant item, trigger event, query state), analytics tools (player metrics, economy metrics, combat metrics)
  • 97.4.1.6 Implement MCP server for Nous: expose training tools (launch training, monitor progress, evaluate checkpoint), safety tools (check content, classify risk, detect injection), model tools (serve, quantize, merge)
  • 97.4.1.7 Implement MCP server for Veritas: expose news tools (research, write, fact-check, translate), editorial tools (prioritize, schedule, publish), analytics tools (engagement metrics, bias analysis)
  • 97.4.1.8 Implement MCP server for remaining domains: Psyche (avatar, voice, emotion), Hathor (world, NPC, narrative), Metis (lecture, assessment, tutor), Yemaya (project, asset, pipeline), Kuan Yin (moderate, protect, heal), Euterpe (compose, arrange, produce), and all other domains
  • 97.4.1.9 Build MCP server registry (internal): catalog all Oshun MCP servers with capabilities, versioning, health status, and usage metrics — discoverable via semantic search

97.4.2 MCP Skill Wrapping & Marketplace#

  • 97.4.2.1 Build MCP tool-to-skill wrapper: automatically generate SKILL.md files that wrap MCP tools with domain-specific instructions, examples, error handling, and prompt templates — transforming raw MCP tools into composable skills
  • 97.4.2.2 Build internal skill marketplace (Oshun Skills Hub): browse, search, install, rate, and review skills created across all domains — with quality scores, usage statistics, and domain categorization
  • 97.4.2.3 Integrate Skills.sh (Vercel) for importing community-contributed skills compatible with the Agent Skills Standard
  • 97.4.2.4 Integrate ClawHub for publishing Oshun skills to the broader AI agent ecosystem (semver, security scanning, vector search)
  • 97.4.2.5 Build skill security scanner: validate all skills (internal and imported) for dangerous operations, data exfiltration risks, resource abuse, and supply-chain attacks (following Snyk integration pattern)
  • 97.4.2.6 Implement skill sandboxing tiers: Tier 1 (read-only, no network, no filesystem), Tier 2 (limited filesystem, no network), Tier 3 (filesystem + controlled network), Tier 4 (full access with audit logging)

97.5 Skill Quality, Evaluation & Benchmarking#

97.5.1 Quality Tracking & Evaluation#

  • 97.5.1.1 Build unified skill quality dashboard tracking per-skill: success rate, average latency, cost per execution, user satisfaction (from data flywheel), error rate by type, retry rate, and quality trend over time
  • 97.5.1.2 Implement skill regression testing framework: maintain test cases per skill (input + expected output), run on every skill version update, alert on regressions, prevent publishing if tests fail (following Anthropic Skill Creator 2.0 eval pattern)
  • 97.5.1.3 Build BFCL-style skill evaluation benchmark for Oshun: test function calling accuracy, parallel calling, multi-turn tool use, agentic reasoning, error recovery, and format sensitivity across all domain skills
  • 97.5.1.4 Implement tau-2-Bench-style agent-user interaction evaluation: simulated users interact with Oshun agents using domain skills, measuring task completion, consistency across repetitions, and user satisfaction
  • 97.5.1.5 Build MCPAgentBench-style MCP tool use evaluation: test agents using Oshun MCP servers on real domain tasks, measuring tool selection accuracy, composition quality, and end-to-end success
  • 97.5.1.6 Implement skill degradation detection: statistical process control on skill quality metrics → alert when quality drops below 2 standard deviations from baseline → trigger auto-improvement cycle (97.3.3)

97.5.2 Process Reward Models for Skill Execution#

  • 97.5.2.1 Build an AgentPRM-style process reward model that scores each step of a skill chain using Monte-Carlo rollouts, and train it. Needs an owner decision on a compute and data budget — this is model training/fine-tuning, not a coding task (stated 2026-09-18). blocked:governance
  • 97.5.2.2 Implement ToolPRMBench-style evaluation for Oshun skill chains: convert multi-step skill execution trajectories into step-level test cases, evaluate both single-step and multi-step failure detection
  • 97.5.2.3 Build hierarchical reward model that evaluates individual skill steps AND consecutive step sequences at fine-grained and coarse-grained levels
  • 97.5.2.4 Implement step-level skill improvement: when PRM identifies a weak step in a skill chain, trigger targeted improvement (regenerate that step's skill code, fine-tune the model on that step's data, or replace with an alternative skill)

97.6 Skill-Specific Model Training#

97.6.1 Tool-Use Fine-Tuning Pipeline#

  • 97.6.1.1 Build skill execution data collector that transforms skill telemetry (97.1.2.2) into tool-use fine-tuning format: {system prompt with tool schemas, user query, assistant response with tool calls, tool results, final response} — feeding Phase 87 dataset registry
  • 97.6.1.2 Build APIGen-MT-style multi-turn skill-use training data generator: Phase 1 (task blueprint generation with ground-truth skill actions, validated by LLM committee), Phase 2 (simulated dialogue generating realistic multi-turn conversations, retaining only trajectories matching expected ground-truth)
  • 97.6.1.3 Build ToolACE-R-style model-aware iterative training for skill use: progressively adjust training data difficulty based on model's evolving capabilities, with adaptive self-refinement at inference time
  • 97.6.1.4 Implement the xLAM-style tool-use fine-tuning pipeline and fine-tune Oshun's self-hosted LLMs (Phase 89) into domain-expert tool-use models. Needs an owner decision on a compute and data budget — this is model training/fine-tuning, not a coding task (stated 2026-09-18). blocked:governance
  • 97.6.1.5 Build ToolMind-style function graph construction: build graph of Oshun skills based on parameter correlations → sample skill chains via random walks → generate diverse multi-step training scenarios → turn-level quality filtering
  • 97.6.1.6 Gorilla RAFT for Oshun skills. Split 2026-09-18.
    • 97.6.1.6.a Build the retrieval half at inference in libs/oshun/skill-system/src/discovery.ts: index skill documentation and, at invocation time, retrieve the up-to-date doc for the chosen skill and put it in the model's context. Verify: a spec asserts the retriever returns the correct skill doc for a query and that a changed doc is reflected without re-embedding the whole corpus.
    • 97.6.1.6.b Retrieval-augmented fine-tuning (RAFT) of the invocation model. Needs an owner decision on a compute and data budget (stated 2026-09-18). blocked:governance

97.6.2 Skill Learning from Demonstrations#

  • 97.6.2.1 Build skill learning from demonstration (LfD) pipeline: capture expert user sessions → extract skill invocation patterns → identify successful action sequences → codify as new skills or improve existing ones
  • 97.6.2.2 Implement behavioral cloning for skill acquisition: train models to replicate successful skill-usage patterns from large-scale cross-domain user interaction data. The data does not exist (large-scale user interaction data); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.6.2.3 Build AutoTIR-style autonomous tool-integrated reasoning: train via RL to decide whether and which skill to invoke, with a hybrid reward. Needs an owner decision on a compute and data budget — this is model training/fine-tuning, not a coding task (stated 2026-09-18). blocked:governance
  • 97.6.2.4 Implement o3/o4-pattern RL-trained skill reasoning so the model uses skills natively within its chain of thought. (Restated 2026-09-18: the original had no measurable target; the owner decision must also set the eval and the success bar.) Needs an owner decision on a compute and data budget — this is model training/fine-tuning, not a coding task (stated 2026-09-18). blocked:governance

97.7 Per-Domain Skill Enhancement#

97.7.1 Iris Agent Skill Enhancement#

  • 97.7.1.1 Migrate Iris tool framework to unified skill registry (adapt ToolId/ToolVersion/ToolDefinition to UniversalSkill, preserve existing tool discovery and composition capabilities)
  • 97.7.1.2 Build VOYAGER-style autonomous tool library growth for Iris: automatic curriculum proposes new tool-use challenges → generate tool compositions → verify via execution → add to library
  • 97.7.1.3 Implement MCP skill wrapping for all Iris tools: each tool gets a SKILL.md wrapper with instructions, examples, and context
  • 97.7.1.4 Build the tool-use fine-tuning pipeline for the Iris conversation model from production tool-call data. The data does not exist (production tool-call traffic from Iris); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.7.1.5 Implement confidence-based tool selection: when Iris model is uncertain which tool to use, expose multiple options to user or run parallel tools and compare results

97.7.2 Maya Game Skill Enhancement#

  • 97.7.2.1 Build dynamic ability generation: from player combat data, find coverage gaps, procedurally generate balanced abilities and playtest them. The data does not exist (player combat telemetry and playtest cohorts); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.7.2.2 Implement ML-based combo discovery from player combat sequences, codifying effective combinations as named combos. The data does not exist (player combat sequence data); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.7.2.3 Build NPC skill learning from player behavior for emergent difficulty scaling. The data does not exist (observed player combat strategies); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.7.2.4 Implement Eureka-style automatic reward-function design for NPC AI: the assistant model (OpenRouter deepseek/deepseek-v4-flash-0731) generates candidate reward functions for a stated NPC behaviour goal, each is scored in the existing simulator, and the loop iterates on the best. This needs no training and no production data. Verify: a spec runs the loop for one goal (e.g. "guard patrols and investigates noises") over a fixed simulator seed and asserts the selected reward's simulated score beats the initial candidate and a hand-written baseline.

97.7.3 Nous Training Skill Enhancement#

  • 97.7.3.1 Build training recipe auto-selector: given a fine-tuning task description + dataset characteristics + compute budget → automatically recommend optimal training method (LoRA vs QLoRA vs full FT), optimizer (AdamW vs Muon), and hyperparameters
  • 97.7.3.2 Implement training recipe composition: chain multiple training stages (SFT → DPO → GRPO) as a composed skill with automatic data handoff, checkpoint management, and progressive evaluation
  • 97.7.3.3 Build safety ensemble optimizer: analyze safety check accuracy across 25+ detectors → optimize ensemble weights and routing → maximize detection rate while minimizing false positives

97.7.4 Isis Generation Skill Enhancement#

  • 97.7.4.1 Build auto-workflow generator: given a generation task description → automatically compose a ComfyUI/pipeline workflow from available generation skills → estimate quality and cost → execute
  • 97.7.4.2 Implement learned parameter optimization from production generation-parameter → quality correlations. The data does not exist (production generation-quality data); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.7.4.3 Build workflow quality predictor: given a workflow definition and parameters → predict expected output quality before execution → route to cheaper/faster workflow if predicted quality exceeds threshold

97.7.5 Veritas Editorial Skill Enhancement#

  • 97.7.5.1 Build editorial skill improvement: fine-tune agent prompts on the highest-engagement/accuracy/trust newsroom outputs. The data does not exist (production article-performance data); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.7.5.2 Implement beat-specific skill specialization through continuous execution feedback. The data does not exist (a history of agent execution feedback per beat); no production users or history exist to learn from (stated 2026-09-18). blocked:corpus
  • 97.7.5.3 Build editorial skill transfer: when one agent records an effective reporting technique, propagate it to agents on other beats. Implement the mechanism in libs/oshun/skill-system/src/composition.ts — a technique registry an agent publishes to and others subscribe from, with beat-tagging and conflict handling. Verify: a spec has agent A publish a technique, asserts agents B and C (different beats) receive it, that a beat-scoped technique is not force-applied where it does not fit, and that a duplicate publish is idempotent. The upstream discovery of which techniques work is 97.7.5.1 (corpus-blocked); this item is the propagation plumbing and stands alone.

97.7.6 All Remaining Domains#

  • 97.7.6.1 Migrate Psyche expression/accessibility/safety skills to unified framework with quality tracking and MCP exposure
  • 97.7.6.2 Migrate Hathor NPC behavior/narrative skills to unified framework with quality tracking, personality consistency scoring, and MCP exposure
  • 97.7.6.3 Migrate Metis educational agent/assessment skills to unified framework with learning outcome tracking and MCP exposure
  • 97.7.6.4 Migrate Yemaya production pipeline/QA skills to unified framework with pipeline efficiency tracking and MCP exposure
  • 97.7.6.5 Migrate Bellona code generation skills to unified framework with compilation success tracking and MCP exposure
  • 97.7.6.6 Migrate Euterpe music generation/production skills to unified framework with audio quality tracking and MCP exposure
  • 97.7.6.7 Migrate Shakti fitness/training skills to unified framework with form quality tracking and MCP exposure
  • 97.7.6.8 Migrate Aglaea beauty/styling skills to unified framework with user satisfaction tracking and MCP exposure
  • 97.7.6.9 Migrate Maat strategic analysis skills to unified framework with prediction accuracy tracking and MCP exposure
  • 97.7.6.10 Migrate Aphrodite game strategy/streaming skills to unified framework with engagement tracking and MCP exposure
  • 97.7.6.11 Migrate Uzume live production skills to unified framework with broadcast quality tracking and MCP exposure
  • 97.7.6.12 Migrate Kuan Yin safety/moderation skills to unified framework with intervention effectiveness tracking and MCP exposure
  • 97.7.6.13 Migrate Demeter/Asase agriculture skills to unified framework with yield prediction tracking and MCP exposure
  • 97.7.6.14 Migrate Cybele real estate/construction skills to unified framework with valuation accuracy tracking and MCP exposure
  • 97.7.6.15 Migrate Themis governance/compliance skills to unified framework with governance effectiveness tracking and MCP exposure
  • 97.7.6.16 Migrate Nisaba/Mnemosyne language/learning skills to unified framework with proficiency improvement tracking and MCP exposure
  • 97.7.6.17 Migrate Calliope creative/artist skills to unified framework with creative consistency tracking and MCP exposure
  • 97.7.6.18 Migrate Galatea robotics skills to unified framework with motor control accuracy tracking and MCP exposure
  • 97.7.6.19 Migrate Oya drone/swarm skills to unified framework with flight safety tracking and MCP exposure
  • 97.7.6.20 Migrate all remaining domain skills (Nyx, Tara, Meditation, Aje, Freya, Brigid, Saraswati, Lakshmi, Annapurna, Athena, Seshat, Airmid) to unified framework with domain-appropriate quality tracking and MCP exposure