@yamo/memory-mesh 2.0.1 → 2.1.1

package/README.md

@@ -2,12 +2,16 @@
 
 Portable, semantic memory system for AI agents with automatic Layer 0 sanitization.
 
+Built on the [YAMO Protocol](https://github.com/yamo-protocol) for transparent agent collaboration with structured workflows and immutable provenance.
+
 ## Features
 
-- **Persistent Vector Storage**: Powered by LanceDB.
-- **Layer 0 Scrubber**: Automatically sanitizes, deduplicates, and cleans content.
+- **Persistent Vector Storage**: Powered by LanceDB for semantic search.
+- **Layer 0 Scrubber**: Automatically sanitizes, deduplicates, and cleans content before embedding.
 - **Local Embeddings**: Runs 100% locally using ONNX (no API keys required).
 - **Portable CLI**: Simple JSON-based interface for any agent or language.
+- **YAMO Skills Integration**: Includes yamo-super workflow system with automatic memory learning.
+- **Pattern Recognition**: Workflows automatically store and retrieve execution patterns for optimization.
 
 ## Installation
 
@@ -45,31 +49,45 @@ const results = await mesh.search('query');
 To use MemoryMesh with your Claude Code skills (like `yamo-super`) in a new project:
 
 ### 1. Install the Package
-This installs the heavy dependencies (LanceDB, ONNX) and binaries.
 
 ```bash
 npm install @yamo/memory-mesh
-# Or install locally if developing:
-# npm install /path/to/memory-mesh
 ```
 
-### 2. Setup the CLI Adapter
-YAMO skills learn how to use the memory system by reading the source code of the CLI adapter. You must ensure `tools/memory_mesh.js` exists in your project so the agent can "see" the interface.
+### 2. Run Setup
+
+This installs YAMO skills to `~/.claude/skills/memory-mesh/` and tools to `./tools/`:
 
-**Quick Setup:**
 ```bash
-mkdir -p tools
-cp node_modules/@yamo/memory-mesh/bin/memory_mesh.js tools/memory_mesh.js
+npx memory-mesh-setup
 ```
 
-### 3. Run Your Skill
-Your `yamo-super` skill (or any skill referencing `memory_script;tools/memory_mesh.js`) will now work automatically.
+The setup script will:
+- Copy YAMO skills (`yamo-super`, `scrubber`) to Claude Code
+- Copy CLI tools to your project's `tools/` directory
+- Prompt before overwriting existing files
+
+### 3. Use the Skills
+
+Your skills are now available in Claude Code with automatic memory integration:
 
 ```bash
-claude "Run yamo-super task='Setup CI pipeline'"
+# Use yamo-super workflow system
+# Automatically retrieves similar past workflows and stores execution patterns
+claude /yamo-super
+
+# Use scrubber skill for content sanitization
+claude /scrubber content="raw text"
 ```
 
-The agent will read `tools/memory_mesh.js`, understand how to call it, and execute memory operations which are handled by the installed `@yamo/memory-mesh` package.
+**Memory Integration Features:**
+- **Workflow Orchestrator**: Searches for similar past workflows before starting
+- **Design Phase**: Stores validated designs with metadata
+- **Debug Phase**: Retrieves similar bug patterns and stores resolutions
+- **Review Phase**: Stores code review outcomes and quality metrics
+- **Complete Workflow**: Stores full execution pattern for future optimization
+
+YAMO agents will automatically find tools in `tools/memory_mesh.js` and `tools/scrubber.js`.
 
 ## Docker
 
@@ -78,3 +96,34 @@ docker run -v $(pwd)/data:/app/runtime/data \
   yamo/memory-mesh store "Content"
 ```
 
+## About YAMO Protocol
+
+Memory Mesh is built on the **YAMO (Yet Another Markup for Orchestration) Protocol** - a structured language for transparent AI agent collaboration with immutable provenance tracking.
+
+**YAMO Protocol Features:**
+- **Structured Agent Workflows**: Semicolon-terminated constraints, explicit handoff chains
+- **Meta-Reasoning Traces**: Hypothesis, rationale, confidence, and observation annotations
+- **Blockchain Integration**: Immutable audit trails via Model Context Protocol (MCP)
+- **Multi-Agent Coordination**: Designed for transparent collaboration across organizational boundaries
+
+**Learn More:**
+- **YAMO Protocol Organization**: [github.com/yamo-protocol](https://github.com/yamo-protocol)
+- **Protocol Specification**: See the YAMO RFC documents for core syntax and semantics
+- **Ecosystem**: Explore other YAMO-compliant tools and skills
+
+Memory Mesh implements YAMO v2.1.0 compliance with:
+- MemorySystemInitializer agent for graceful degradation
+- Context passing between agents (`from_AgentName.output`)
+- Structured logging with meta-reasoning
+- Priority levels and constraint-based execution
+- Automatic workflow pattern storage for continuous learning
+
+**Related YAMO Projects:**
+- [yamo-chain](https://github.com/yamo-protocol/yamo-protocol) - Blockchain integration for agent provenance
+
+## Documentation
+
+- **Architecture Guide**: [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) - Comprehensive system architecture (1,118 lines)
+- **Development Guide**: [CLAUDE.md](CLAUDE.md) - Guide for Claude Code development
+- **Marketplace**: [.claude-plugin/marketplace.json](.claude-plugin/marketplace.json) - Plugin metadata
+

package/bin/setup.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+/**
+ * Memory Mesh Setup Script
+ * Installs YAMO skills and tools into your project and Claude Code environment
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join, resolve } from 'path';
+import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = resolve(__dirname, '..');
+const FORCE_MODE = process.argv.includes('--force') || process.argv.includes('-f');
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${COLORS[color]}${message}${COLORS.reset}`);
+}
+
+function promptUser(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${COLORS.yellow}${question}${COLORS.reset} `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().trim());
+    });
+  });
+}
+
+async function copyWithPrompt(src, dest, label) {
+  if (existsSync(dest) && !FORCE_MODE) {
+    const answer = await promptUser(`${label} already exists at ${dest}. Overwrite? (y/n)`);
+    if (answer !== 'y' && answer !== 'yes') {
+      log(`  ⏭  Skipped ${label}`, 'yellow');
+      return false;
+    }
+  }
+
+  try {
+    copyFileSync(src, dest);
+    log(`  ✓ Installed ${label}`, 'green');
+    return true;
+  } catch (error) {
+    log(`  ✗ Failed to install ${label}: ${error.message}`, 'red');
+    return false;
+  }
+}
+
+async function installSkills() {
+  log('\n📦 Installing YAMO Skills...', 'blue');
+
+  const claudeSkillsDir = join(homedir(), '.claude', 'skills', 'memory-mesh');
+
+  // Check if Claude Code is installed
+  const claudeDir = join(homedir(), '.claude');
+  if (!existsSync(claudeDir)) {
+    log('⚠  Claude Code not detected (~/.claude not found)', 'yellow');
+    log('   Skills will be skipped. Install Claude Code first.', 'yellow');
+    return { installed: 0, skipped: 0 };
+  }
+
+  // Create skills directory
+  if (!existsSync(claudeSkillsDir)) {
+    mkdirSync(claudeSkillsDir, { recursive: true });
+    log(`  ✓ Created ${claudeSkillsDir}`, 'green');
+  }
+
+  const skillsSourceDir = join(packageRoot, 'skills');
+  if (!existsSync(skillsSourceDir)) {
+    log('  ✗ Skills directory not found in package', 'red');
+    return { installed: 0, skipped: 0 };
+  }
+
+  // Copy all skill files
+  const skillFiles = readdirSync(skillsSourceDir).filter(f =>
+    f.endsWith('.md') || f.endsWith('.yamo')
+  );
+
+  let installed = 0;
+  let skipped = 0;
+
+  for (const file of skillFiles) {
+    const src = join(skillsSourceDir, file);
+    const dest = join(claudeSkillsDir, file);
+    const success = await copyWithPrompt(src, dest, file);
+    if (success) installed++;
+    else skipped++;
+  }
+
+  return { installed, skipped };
+}
+
+async function installTools() {
+  log('\n🔧 Installing Tools...', 'blue');
+
+  const toolsDir = join(process.cwd(), 'tools');
+
+  // Create tools directory if it doesn't exist
+  if (!existsSync(toolsDir)) {
+    mkdirSync(toolsDir, { recursive: true });
+    log(`  ✓ Created ${toolsDir}`, 'green');
+  }
+
+  const toolFiles = [
+    { src: 'memory_mesh.js', name: 'Memory Mesh CLI' },
+    { src: 'scrubber.js', name: 'Scrubber CLI' }
+  ];
+
+  let installed = 0;
+  let skipped = 0;
+
+  for (const { src, name } of toolFiles) {
+    const srcPath = join(packageRoot, 'bin', src);
+    const destPath = join(toolsDir, src);
+
+    if (!existsSync(srcPath)) {
+      log(`  ✗ ${name} not found in package`, 'red');
+      skipped++;
+      continue;
+    }
+
+    const success = await copyWithPrompt(srcPath, destPath, name);
+    if (success) installed++;
+    else skipped++;
+  }
+
+  return { installed, skipped };
+}
+
+function showUsage() {
+  const pkg = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf-8'));
+
+  log('\n✨ Setup Complete!', 'bright');
+  log('\nYAMO Skills installed to: ~/.claude/skills/memory-mesh/', 'blue');
+  log('Tools installed to: ./tools/', 'blue');
+
+  log('\n📚 Usage:', 'bright');
+  log('  • Use /yamo-super in Claude Code for workflow automation');
+  log('  • Use /scrubber skill for content sanitization');
+  log('  • Call tools/memory_mesh.js for memory operations');
+
+  log('\n🔗 Learn more:', 'bright');
+  log('  README: https://github.com/soverane-labs/memory-mesh');
+  log(`  Version: ${pkg.version}`);
+}
+
+async function main() {
+  log('\n╔════════════════════════════════════════╗', 'bright');
+  log('║   Memory Mesh Setup                    ║', 'bright');
+  log('║   Installing skills and tools...       ║', 'bright');
+  log('╚════════════════════════════════════════╝', 'bright');
+
+  try {
+    // Install skills to ~/.claude/skills/memory-mesh/
+    const skillResults = await installSkills();
+
+    // Install tools to ./tools/
+    const toolResults = await installTools();
+
+    // Summary
+    const totalInstalled = skillResults.installed + toolResults.installed;
+    const totalSkipped = skillResults.skipped + toolResults.skipped;
+
+    log('\n' + '─'.repeat(40));
+    log(`✓ Installed: ${totalInstalled}`, 'green');
+    if (totalSkipped > 0) {
+      log(`⏭  Skipped: ${totalSkipped}`, 'yellow');
+    }
+
+    if (totalInstalled > 0) {
+      showUsage();
+    }
+
+    log('');
+    process.exit(0);
+  } catch (error) {
+    log(`\n✗ Setup failed: ${error.message}`, 'red');
+    log(`  ${error.stack}`, 'red');
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@yamo/memory-mesh",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Portable semantic memory system with Layer 0 Scrubber for YAMO agents",
   "type": "module",
   "main": "lib/memory/index.js",
   "types": "index.d.ts",
   "bin": {
     "memory-mesh": "./bin/memory_mesh.js",
-    "scrubber": "./bin/scrubber.js"
+    "scrubber": "./bin/scrubber.js",
+    "memory-mesh-setup": "./bin/setup.js"
   },
   "files": [
     "lib/",

package/skills/SKILL.md

@@ -1,18 +1,18 @@
 ---
 name: yamo-super
-description: YamoSuper is a comprehensive AI coding workflow system that orchestrates the complete software development lifecycle through specialized agents managing brainstorming, git worktree isolation, implementation planning, dual execution modes (fresh-subagent-per-task with two-stage review or batch with checkpoints), strict test-driven development, systematic debugging, and pre-merge quality gates—all designed to enable autonomous execution while maintaining human oversight and enforcing YAGNI/DRY best practices.
+description: YamoSuper is a comprehensive AI coding workflow system that orchestrates the complete software development lifecycle through specialized agents managing brainstorming, git worktree isolation, implementation planning, dual execution modes (fresh-subagent-per-task with two-stage review or batch with checkpoints), strict test-driven development, systematic debugging, and pre-merge quality gates—all designed to enable autonomous execution while maintaining human oversight and enforcing YAGNI/DRY best practices with persistent memory integration.
 ---
 
-when improving or creating new code follow the this yamo-skill:
+For all code improvement or creation tasks, strictly adhere to the logic, agents, and constraints defined in this Yamo Skill:
 
 metadata:
   name;YamoSuper;
-  version;2.0.0;
-  description;Comprehensive AI coding workflow system consolidating test-driven development, systematic debugging, collaborative planning, and proven software engineering patterns with persistent memory of past workflows;
+  version;2.1.0;
+  description;Comprehensive AI coding workflow system with automatic memory integration for pattern recognition and workflow optimization;
   author;Derived from Superpowers by Jesse Scott;adapted for YAMO by Soverane Labs;
   license;MIT;
-  tags;tdd;debugging;collaboration;planning;workflow;subagent;git;review;memory;
-  capabilities;brainstorm_design;write_implementation_plan;execute_plan_batch;test_driven_development;systematic_debugging;verification;code_review;git_worktree;subagent_driven;parallel_dispatch;retrieve_workflow_patterns;store_execution_history;
+  tags;tdd;debugging;collaboration;planning;workflow;subagent;git;review;memory;semantic_search;
+  capabilities;brainstorm_design;write_implementation_plan;execute_plan_batch;test_driven_development;systematic_debugging;verification;code_review;git_worktree;subagent_driven;parallel_dispatch;retrieve_workflow_patterns;store_execution_history;semantic_memory;
   parameters:
     workflow_mode:
       type;string;
@@ -31,24 +31,51 @@ metadata:
   environment:
     requires_filesystem;true;
     requires_local_storage;true;
-    notes;Creates worktrees, writes plans, manages git workflows, and stores execution history in Memory Mesh;
+    notes;Creates worktrees, writes plans, manages git workflows, and stores execution history in Memory Mesh via tools/memory_mesh.js;
   dependencies:
     required:
       - Git >= 2.30.0
       - Node >= 18.0.0 (for npm test commands)
       - MemoryMesh >=1.0.0;
+      - tools/memory_mesh.js;
     optional:
       - YamoChainClient (for blockchain anchoring)
 ---
+agent: MemorySystemInitializer;
+intent: verify_memory_system_availability;
+context:
+  memory_tool;tools/memory_mesh.js;
+  memory_enabled;provided_by_user.memory_enabled;
+constraints:
+  - if_memory_enabled;verify_tool_exists;
+  - test_memory_connection_with_search;
+  - if_memory_unavailable;warn_user;continue_without_memory;
+  - set_memory_status_flag;
+priority: high;
+output: memory_status.json;
+log: memory_initialized;available;timestamp;
+meta:
+  hypothesis;Memory system availability check prevents runtime failures;
+  rationale;Graceful degradation if memory unavailable;
+  confidence;0.98;
+handoff: WorkflowOrchestrator;
+---
 agent: WorkflowOrchestrator;
-intent: determine_workflow_entry_point;
+intent: determine_workflow_entry_point_with_historical_context;
 context:
   user_request;raw_input;
   project_state;current_git_status;recent_commits;file_tree;
   available_modes;brainstorm;plan;execute;debug;review;
-  memory_script;tools/memory_mesh.js;
+  memory_status;from_MemorySystemInitializer;
+  memory_tool;tools/memory_mesh.js;
   memory_enabled;provided_by_user.memory_enabled;
 constraints:
+  - if_memory_available;search_similar_workflows;
+    - extract_keywords_from_user_request;
+    - search_query_format;"workflow mode project outcome";
+    - retrieve_top_3_similar_patterns;
+    - analyze_past_outcomes_success_failure;
+    - present_similar_patterns_to_inform_decision;
   - check_if_creative_work_requested;trigger_brainstorming_agent;
   - check_if_spec_exists;trigger_planning_agent;
   - check_if_plan_exists;trigger_execution_agent;
@@ -56,21 +83,25 @@ constraints:
   - check_if_review_requested;trigger_review_agent;
   - default_to_brainstorming_if_uncertain;
   - announce_active_workflow_to_user;
-  - retrieve_similar_past_workflows;
 priority: critical;
 output: workflow_decision.json;
-log: workflow_determined;timestamp;mode_selected;
+log: workflow_determined;timestamp;mode_selected;past_patterns_found;
 meta:
-  hypothesis;Clear workflow entry point prevents context confusion;
-  rationale;Different development phases require distinct mindsets and tools;
+  hypothesis;Historical workflow patterns improve decision accuracy;
+  rationale;Similar past workflows provide context for current decision;
+  confidence;0.92;
+  observation;Past success patterns should bias toward proven approaches;
 handoff: BrainstormingAgent;
 ---
 agent: BrainstormingAgent;
 intent: refine_ideas_through_socratic_dialogue;
 context:
   project_state;from_WorkflowOrchestrator;
+  workflow_decision;from_WorkflowOrchestrator;
   user_idea;raw_request;
+  past_patterns;from_WorkflowOrchestrator.similar_workflows;
 constraints:
+  - if_past_patterns_exist;reference_successful_approaches;
   - check_project_context_first;files;docs;recent_commits;
   - ask_questions_one_at_a_time;
   - prefer_multiple_choice_when_possible;
@@ -82,10 +113,11 @@ constraints:
   - apply_yagni_ruthlessly;
 priority: high;
 output: validated_design.md;
-log: design_validated;timestamp;sections_reviewed;
+log: design_validated;timestamp;sections_reviewed;alternatives_proposed;
 meta:
   hypothesis;Incremental validation produces better designs;
   rationale;Large designs overwhelm;section-by-section enables feedback;
+  confidence;0.94;
 handoff: DocumentationAgent;
 ---
 agent: DocumentationAgent;
@@ -93,17 +125,23 @@ intent: persist_and_commit_design;
 context:
   design;from_BrainstormingAgent;
   destination;docs/plans/YYYY-MM-DD-<topic>-design.md;
+  memory_tool;tools/memory_mesh.js;
+  memory_status;from_MemorySystemInitializer;
 constraints:
   - use_clear_concise_writing;
   - commit_to_git_with_descriptive_message;
   - tag_commit_with_design_reviewed;
+  - if_memory_available;store_design_summary;
+    - content_format;"Design phase: <topic>. Approach: <architecture>. Components: <list>. Status: validated.";
+    - metadata;{workflow:"yamo-super",phase:"design",project:"<name>",timestamp:"<iso>",commit_sha:"<sha>"};
   - ask_ready_for_implementation;
 priority: medium;
-output: design_file_path;commit_sha;
-log: design_documented;timestamp;file_path;commit_sha;
+output: design_file_path;commit_sha;memory_id;
+log: design_documented;timestamp;file_path;commit_sha;memory_stored;
 meta:
   hypothesis;Documented designs enable better implementation;
   rationale;Written specs prevent drift during coding;
+  confidence;0.96;
 handoff: WorktreeAgent;
 ---
 agent: WorktreeAgent;
@@ -119,10 +157,11 @@ constraints:
   - document_worktree_location;
 priority: high;
 output: worktree_path;branch_name;
-log: workspace_created;timestamp;path;branch;
+log: workspace_created;timestamp;path;branch;baseline_tests;
 meta:
   hypothesis;Isolated worktrees prevent main branch pollution;
   rationale;Clean branches enable easy rollback and parallel development;
+  confidence;0.99;
 handoff: PlanningAgent;
 ---
 agent: PlanningAgent;
@@ -130,11 +169,13 @@ intent: create_detailed_implementation_plan;
 context:
   design;from_DocumentationAgent;
   worktree_path;from_WorktreeAgent;
+  past_patterns;from_WorkflowOrchestrator.similar_workflows;
   assumptions;
     engineer_has_zero_codebase_context;
     engineer_has_questionable_taste;
     engineer_needs_explicit_instructions;
 constraints:
+  - if_similar_plans_exist;adapt_proven_task_breakdowns;
   - break_into_bite_sized_tasks;2_5_minutes_each;
   - each_task_one_action;write_test;run_test;implement;verify;commit;
   - specify_exact_file_paths;
@@ -147,10 +188,11 @@ constraints:
   - include_sub_skill_directive;use_superpowers:executing_plans;
 priority: critical;
 output: implementation_plan.md;
-log: plan_created;timestamp;task_count;
+log: plan_created;timestamp;task_count;file_path;
 meta:
   hypothesis;Explicit plans enable autonomous subagent execution;
   rationale;Zero_context engineers need complete information;
+  confidence;0.97;
 handoff: ExecutionSelector;
 ---
 agent: ExecutionSelector;
@@ -169,6 +211,7 @@ log: execution_mode_selected;timestamp;mode;
 meta:
   hypothesis;Choice accommodates different working styles;
   rationale;Some prefer continuity;others prefer isolation;
+  confidence;0.91;
 handoff: SubagentDriver;
 ---
 agent: SubagentDriver;
@@ -197,11 +240,12 @@ constraints:
   - always_provide_full_text_not_file_references;
   - ensure_scene_setting_context_per_task;
 priority: critical;
-output: implementation_complete;all_commits;
-log: execution_complete;timestamp;tasks_completed;commits;
+output: implementation_complete;all_commits;test_results;
+log: execution_complete;timestamp;tasks_completed;commits;tests_passed;
 meta:
   hypothesis;Fresh subagents per task prevent context pollution;
   rationale;Two_stage_review ensures_spec_compliance_and_code_quality;
+  confidence;0.95;
 handoff: BatchExecutor;
 ---
 agent: BatchExecutor;
@@ -211,7 +255,7 @@ context:
   worktree_path;from_WorktreeAgent;
 constraints:
   - group_tasks_into_logical_batches;
-  - execute_batch sequentially;
+  - execute_batch_sequentially;
   - after_each_batch;
     - run_all_tests;verify_passing;
     - request_human_checkpoint;
@@ -224,6 +268,7 @@ log: batch_execution_complete;timestamp;batches;checkpoints_passed;
 meta:
   hypothesis;Checkpoints maintain human oversight;
   rationale;Batch execution balances autonomy_with_control;
+  confidence;0.93;
 handoff: TDDAgent;
 ---
 agent: TDDAgent;
@@ -261,13 +306,20 @@ log: tdd_cycle_complete;timestamp;test_name;status;
 meta:
   hypothesis;Watching_test_fail_proves_it_tests_something;
   rationale;tests_after_answer_what_does_this_do;tests_first_answer_what_should_this_do;
+  confidence;0.99;
 handoff: DebuggingAgent;
 ---
 agent: DebuggingAgent;
 intent: systematic_root_cause_analysis;
 context:
   bug_report;user_report_or_test_failure;
+  memory_tool;tools/memory_mesh.js;
+  memory_status;from_MemorySystemInitializer;
 constraints:
+  - if_memory_available;search_similar_bugs;
+    - extract_error_signature;
+    - search_query_format;"debug error <signature> <component>";
+    - check_past_solutions;
   - phase_1_define_problem;
     - describe_symptoms_precisely;
     - identify_affected_components;
@@ -286,14 +338,19 @@ constraints:
     - write_failing_test_reproducing_bug;
     - apply_tdd_cycle_to_fix;
     - use_verification_before_completion;
+  - if_memory_available;store_bug_resolution;
+    - content_format;"Debug: <error_signature>. Root cause: <cause>. Solution: <fix>. Component: <component>.";
+    - metadata;{workflow:"yamo-super",phase:"debug",bug_type:"<type>",resolution:"<fix>",timestamp:"<iso>"};
   - never_fix_without_test;
   - never_apply_bandages;
 priority: high;
-output: root_cause;fix_verification_test;
-log: bug_resolved;timestamp;root_cause;test_added;
+output: root_cause;fix_verification_test;memory_id;
+log: bug_resolved;timestamp;root_cause;test_added;similar_bugs_found;
 meta:
   hypothesis;Systematic_debugging_faster_than_shotgun_debugging;
   rationale;root_cause_elimination_prevents_reoccurrence;
+  confidence;0.96;
+  observation;Historical bug patterns accelerate diagnosis;
 handoff: VerificationAgent;
 ---
 agent: VerificationAgent;
@@ -316,6 +373,7 @@ log: verification_complete;timestamp;status;regressions;
 meta:
   hypothesis;Verification_catches_incomplete_fixes;
   rationale;feeling_fixed_does_not_mean_fixed;
+  confidence;0.98;
 handoff: CodeReviewAgent;
 ---
 agent: CodeReviewAgent;
@@ -323,6 +381,8 @@ intent: conduct_pre_merge_quality_gate;
 context:
   implementation;from_SubagentDriver_or_BatchExecutor;
   plan;from_PlanningAgent;
+  memory_tool;tools/memory_mesh.js;
+  memory_status;from_MemorySystemInitializer;
 constraints:
   - review_against_plan;
     - all_requirements_implemented;
@@ -341,12 +401,16 @@ constraints:
     - minor;nice_to_have;
   - if_critical_issues;block_progress;
   - if_no_issues;approve;
+  - if_memory_available;store_review_outcome;
+    - content_format;"Code review: <feature>. Quality: <rating>. Issues: <count>. Tests: <coverage>. Outcome: <approved/rejected>.";
+    - metadata;{workflow:"yamo-super",phase:"review",quality_rating:"<rating>",issues_count:"<n>",timestamp:"<iso>"};
 priority: critical;
-output: review_report;approval_status;
+output: review_report;approval_status;memory_id;
 log: review_complete;timestamp;critical;important;minor;status;
 meta:
   hypothesis;Pre_merge_review_catches_issues_early;
   rationale;merge_reviews_are_too_late_for_easy_fixes;
+  confidence;0.97;
 handoff: BranchFinisher;
 ---
 agent: BranchFinisher;
@@ -354,6 +418,7 @@ intent: complete_development_branch_workflow;
 context:
   implementation;from_CodeReviewAgent;
   worktree_path;from_WorktreeAgent;
+  review_report;from_CodeReviewAgent;
 constraints:
   - verify_all_tests_pass;
   - verify_no_regressions;
@@ -372,7 +437,8 @@ log: branch_completed;timestamp;outcome;
 meta:
   hypothesis;Explicit_branch_completion_prevents_orphan_branches;
   rationale;clear_decisions_prevent_branch_accumulation;
-handoff: ParallelDispatcher;
+  confidence;0.95;
+handoff: WorkflowMemoryStore;
 ---
 agent: ParallelDispatcher;
 intent: coordinate_concurrent_subagent_workflows;
@@ -392,6 +458,7 @@ log: parallel_dispatch_complete;timestamp;tasks;conflicts;
 meta:
   hypothesis;Parallel_execution_saves_wall_clock_time;
   rationale;independent_tasks_have_no_dependencies;
+  confidence;0.89;
 handoff: SkillMetaAgent;
 ---
 agent: SkillMetaAgent;
@@ -416,6 +483,7 @@ log: skill_created;timestamp;name;category;
 meta:
   hypothesis;Meta_skills_enable_ecosystem_growth;
   rationale;extensible_systems_adapt_to_new_needs;
+  confidence;0.88;
 handoff: End;
 ---
 agent: UsageGuide;
@@ -432,6 +500,7 @@ constraints:
     - systematic_debugging;root_cause_analysis;
     - requesting_code_review;quality_gate;
     - finishing_development_branch;merge_pr_discard;
+    - memory_integration;pattern_recognition;
   - explain_skills_trigger_automatically;
   - explain_mandatory_not_suggestions;
   - demonstrate_with_example;
@@ -441,22 +510,46 @@ log: onboarded;timestamp;user;
 meta:
   hypothesis;clear_introduction_enables_effective_use;
   rationale;understanding_why_builds_compliance;
+  confidence;0.92;
 handoff: WorkflowMemoryStore;
 ---
 agent: WorkflowMemoryStore;
-intent: store_workflow_execution_for_pattern_recognition;
+intent: store_complete_workflow_execution_for_pattern_recognition;
 context:
   workflow_decision;from_WorkflowOrchestrator;
-  memory_script;tools/memory_mesh.js;
-  memory_enabled;provided_by_user.memory_enabled;
+  design_output;from_DocumentationAgent;
+  implementation_result;from_SubagentDriver_or_BatchExecutor;
+  review_result;from_CodeReviewAgent;
+  branch_outcome;from_BranchFinisher;
+  memory_tool;tools/memory_mesh.js;
+  memory_status;from_MemorySystemInitializer;
 constraints:
+  - if_memory_available;store_complete_workflow;
+    - aggregate_all_phase_data;
+    - content_format;"Workflow: yamo-super. Mode: <mode>. Project: <project>. Design: <summary>. Implementation: <tasks_completed>. Review: <quality>. Tests: <passed/failed>. Outcome: <success/failure>. Duration: <time>.";
+    - metadata;{
+        workflow:"yamo-super",
+        mode:"<selected_mode>",
+        project:"<project_name>",
+        phase:"complete",
+        design_commit:"<sha>",
+        implementation_commits:"<count>",
+        tests_passed:"<true/false>",
+        review_approved:"<true/false>",
+        outcome:"<success/failure>",
+        duration_minutes:"<n>",
+        timestamp:"<iso>"
+      };
   - generate_workflow_embedding;
   - tag_by_mode_project_type_and_outcome;
-  - store_execution_patterns;
   - enable_future_recommendations;
-priority: low;
+  - if_blockchain_available;anchor_to_yamo_chain;
+priority: high;
 output: workflow_memory_receipt.json;
-log: workflow_stored;memory_id;
+log: workflow_stored;memory_id;outcome;timestamp;
 meta:
-  hypothesis;Storing workflows enables pattern recognition for future recommendations;
+  hypothesis;Storing complete workflows enables pattern recognition for future recommendations;
+  rationale;Historical success patterns guide future workflow decisions;
+  confidence;0.94;
+  observation;Semantic search finds similar contexts not just keyword matches;
 handoff: End;