Right, for the sake of closure, below is a small console app I created that uses the DotNetZip lib along with our inhouse sforce DAL to retrieve workflow rules on an object, and then look for one specific workflow rule (setting a coupe of fields for testing).  This gets the zip from the RetrieveRequest and, in stream, converts it to an XDocument for Linq to XML...and all of that.  As is..

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using CSG.Salesforce.Metadata.MetaDefinition;
using Ionic.Zip;
using InternalDAL = CSG.Salesforce.DLL.DAO;
using System.IO;
using System.Xml;
using System.Xml.Linq;

namespace CSG.Salesforce.Metadata
{
    public class Rules : IEnumerable

    {
        private readonly List<RuleDefinition> enumerableList = new List<RuleDefinition>();

        #region Implementation of IEnumerable

        // need to make the list enumerable
        public IEnumerator<RuleDefinition> GetEnumerator()
        {
            return enumerableList.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

        /// <summary>
        /// Add item to the list of items that are being used
        /// </summary>
        /// <param name="o"></param>
        public void Add(RuleDefinition a)
        {
            enumerableList.Add(a);
        }

        public int Length()
        {
            return enumerableList.Count;
        }
    }

    public class RuleDefinition
    {
        public string FullName { get; set; }
        public string Description { get; set; }
    }

    class Program
    {
        public static string ObjectName { get; set; }
        public static string RuleName { get; set; }

        private static InternalDAL.SalesforceDAO _sforce;

       static void Main(string[] args)
        {
           // set props
           ObjectName = "Account";
           RuleName = "Update Renewal Survey Elig for New Client";

           // login to the APIs
           var _svc = Login();

           // pull the results
           var _results = RetrieveMetaObject(_svc); 

           // now to the Zip work
           var _doc = ReadZipIntoXMLDoc(_results);

           // got the xml, now get me an object
           RuleDefinition rule = ParseXMLIntoObject(_doc, RuleName);

           Console.WriteLine(rule.FullName);
        }

       static MetaDefinition.MetadataService Login()
        {
            _sforce = new InternalDAL.SalesforceDAO();
            MetaDefinition.MetadataService _metaSvc = new MetaDefinition.MetadataService();

            CSG.sforce.LoginResult _lr = _sforce.Login();
            _metaSvc.SessionHeaderValue = new MetaDefinition.SessionHeader { sessionId = _lr.sessionId };
            _metaSvc.Url = _lr.metadataServerUrl;

            Console.WriteLine("Logged in as {0}", _lr.userInfo.userName);

           return _metaSvc;
        }

        static MetaDefinition.RetrieveResult RetrieveMetaObject(MetaDefinition.MetadataService metaSvc)
        {
            // create request
            MetaDefinition.RetrieveRequest _request = new MetaDefinition.RetrieveRequest {apiVersion = 18.0, unpackaged = new MetaDefinition.Package()};
            MetaDefinition.PackageTypeMembers _pkgMbrs = new MetaDefinition.PackageTypeMembers { name = "Workflow", members = new string[] { ObjectName } };
            _request.unpackaged.types = new MetaDefinition.PackageTypeMembers[] { _pkgMbrs };

            MetaDefinition.RetrieveResult _results = null;

            // retrieve start
            MetaDefinition.AsyncResult _asyncResult = metaSvc.retrieve(_request);
    
            while (!_asyncResult.done)
            {
                System.Threading.Thread.Sleep(3000);  // wait three seconds
                _asyncResult = metaSvc.checkStatus(new String[] { _asyncResult.id })[0];
            }

            if (_asyncResult.state == MetaDefinition.AsyncRequestState.Error)
                // error, for this quick app just console it.
                Console.WriteLine("{0} {1}", _asyncResult.statusCode, _asyncResult.message);
            else
            {
                // get everything...
                _results = metaSvc.checkRetrieveStatus(_asyncResult.id);
                if (_results.messages != null)
                {
                    // if there are messages, applicationexception them?
                } 
                else
                    return _results;
            }
            return null;
        }

        static XDocument ReadZipIntoXMLDoc(RetrieveResult retrieve)
        {
            // extract the zip from the reeults
            ZipFile zip = ZipFile.Read(retrieve.zipFile);

            foreach (ZipEntry file in zip)
            {
                if (file.FileName == String.Format("unpackaged/workflows/{0}.workflow", ObjectName))
                {
                    byte[] buffer = new byte[0];

                    using (Ionic.Zlib.CrcCalculatorStream s = file.OpenReader())
                    {
                        // buffer needs a length, just use the calced length.
                        buffer = new byte[s.Length];

                        int n, totalBytesRead = 0;
                        do
                        { n = s.Read(buffer, 0, buffer.Length);
                            totalBytesRead += n; } while (n > 0);
                        
                        // file checks...taken directly from the DotNetLib samples.
                        if (s.Crc != file.Crc)
                            throw new Exception(
                                string.Format("The Zip Entry failed the CRC Check. (0x{0:X8}!=0x{1:X8})", s.Crc,
                                              file.Crc));

                        if (totalBytesRead != file.UncompressedSize)
                            throw new Exception(
                                string.Format("We read an unexpected number of bytes. ({0}!={1})",
                                              totalBytesRead, file.UncompressedSize));
                    }

                    MemoryStream stream = new MemoryStream(buffer);
                    return LoadFromStream(stream);
                }
            }
            return null;
        }

        static RuleDefinition ParseXMLIntoObject(XContainer xmlDoc, string ruleName)
        {
            const string xmlns = "http://soap.sforce.com/2006/04/metadata";
            var ruleAttributes = from x in xmlDoc.Descendants(XName.Get("rules", xmlns))
                                 where x.Element(XName.Get("fullName", xmlns)).Value == ruleName
                                 select new RuleDefinition()
                                 {
                                     FullName = (string)x.Element(XName.Get("fullName", xmlns)),
                                     Description = (string)x.Element(XName.Get("description", xmlns))
                                 };

            RuleDefinition rule = new RuleDefinition();
            foreach (var e in ruleAttributes)
            {
                rule = e;
                Console.WriteLine(rule.FullName);
                Console.WriteLine(rule.Description);

            }
            return rule;
        }

        // helpers
        static String[] ListTarget(MetaDefinition.MetadataService metaSvc)
        {
            MetaDefinition.ListMetadataQuery q = new MetaDefinition.ListMetadataQuery();

            List<string> workflows = new List<string>();
            q.type = "Workflow";
            MetaDefinition.FileProperties[] _wkflws = metaSvc.listMetadata(new MetaDefinition.ListMetadataQuery[] { q }, 18);

            foreach (MetaDefinition.FileProperties rp in _wkflws)
            {
                Console.WriteLine("{0}", rp.fileName);
                workflows.Add(rp.fullName);
            }

            return workflows.ToArray();
        }

        static XDocument LoadFromStream(Stream stream)
        {
            using (XmlReader reader = XmlReader.Create(stream))
            {
                return XDocument.Load(reader);
            }
        }

    }

}

I hope this helps anyone out, and thanks for the pointers Simon.

Cheers.

- Bryan