npm - titan-synapse - Versions diffs - 0.1.1 - Mend

titan-synapse 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (62) hide show

package/CONTRIBUTING.md +187 -0
package/Cargo.lock +3976 -0
package/Cargo.toml +10 -0
package/LICENSE +190 -0
package/PROGRESS.md +151 -0
package/README.md +514 -0
package/TEST_LOG.md +220 -0
package/config/default.yaml +36 -0
package/crates/synapse/Cargo.toml +70 -0
package/crates/synapse/src/cli/bench.rs +44 -0
package/crates/synapse/src/cli/eval.rs +395 -0
package/crates/synapse/src/cli/export.rs +45 -0
package/crates/synapse/src/cli/hub.rs +179 -0
package/crates/synapse/src/cli/import.rs +35 -0
package/crates/synapse/src/cli/learn.rs +53 -0
package/crates/synapse/src/cli/mod.rs +10 -0
package/crates/synapse/src/cli/models.rs +36 -0
package/crates/synapse/src/cli/pull.rs +60 -0
package/crates/synapse/src/cli/status.rs +52 -0
package/crates/synapse/src/cli/train.rs +99 -0
package/crates/synapse/src/config.rs +220 -0
package/crates/synapse/src/dashboard.rs +281 -0
package/crates/synapse/src/format/manifest.rs +57 -0
package/crates/synapse/src/format/mod.rs +4 -0
package/crates/synapse/src/format/packer.rs +213 -0
package/crates/synapse/src/inference/engine.rs +361 -0
package/crates/synapse/src/inference/kv_cache.rs +97 -0
package/crates/synapse/src/inference/lora.rs +166 -0
package/crates/synapse/src/inference/mod.rs +9 -0
package/crates/synapse/src/inference/model.rs +167 -0
package/crates/synapse/src/inference/sampler.rs +133 -0
package/crates/synapse/src/inference/speculative.rs +153 -0
package/crates/synapse/src/learn/cloud_fallback.rs +186 -0
package/crates/synapse/src/learn/engine.rs +109 -0
package/crates/synapse/src/learn/mod.rs +5 -0
package/crates/synapse/src/main.rs +185 -0
package/crates/synapse/src/memory/extractor.rs +201 -0
package/crates/synapse/src/memory/graph.rs +332 -0
package/crates/synapse/src/memory/hallucination.rs +259 -0
package/crates/synapse/src/memory/mod.rs +7 -0
package/crates/synapse/src/openai.rs +232 -0
package/crates/synapse/src/server.rs +166 -0
package/crates/synapse/src/streaming.rs +80 -0
package/crates/synapse/src/swarm/coordinator.rs +198 -0
package/crates/synapse/src/swarm/mod.rs +8 -0
package/crates/synapse/src/swarm/orchestrator.rs +225 -0
package/crates/synapse/src/swarm/pool.rs +64 -0
package/crates/synapse/src/swarm/spawner.rs +199 -0
package/crates/synapse/src/swarm/synthesizer.rs +26 -0
package/crates/synapse/src/vram/manager.rs +67 -0
package/crates/synapse/src/vram/mod.rs +3 -0
package/docker-compose.yml +19 -0
package/install.sh +311 -0
package/package.json +36 -0
package/python/Dockerfile.learn +18 -0
package/python/requirements.txt +11 -0
package/python/synapse_learn/__init__.py +0 -0
package/python/synapse_learn/datasets.py +233 -0
package/python/synapse_learn/real_eval.py +616 -0
package/python/synapse_learn/server.py +431 -0
package/python/synapse_learn/train_base.py +672 -0
package/python/synapse_learn/train_specialists.py +787 -0

package/crates/synapse/src/dashboard.rs ADDED Viewed

@@ -0,0 +1,281 @@
+/// Embedded web dashboard — a single HTML page served from Rust.
+/// No React. No build tools. No npm. Just HTML + JS + Tailwind CDN.
+/// Normal people can open a browser and chat with their AI.
+pub const DASHBOARD_HTML: &str = r#"<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>TITAN Synapse</title>
+<script src="https://cdn.tailwindcss.com"></script>
+<style>
+  @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+  body { font-family: 'Inter', sans-serif; background: #0a0a0f; color: #e0e0e0; }
+  .glow { box-shadow: 0 0 20px rgba(139, 92, 246, 0.15); }
+  .pulse { animation: pulse 2s ease-in-out infinite; }
+  @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.6; } }
+  .msg-user { background: linear-gradient(135deg, #1e1b4b 0%, #312e81 100%); }
+  .msg-ai { background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); }
+  #chat-input:focus { box-shadow: 0 0 0 2px rgba(139, 92, 246, 0.5); }
+  .specialist-tag { font-size: 0.65rem; padding: 1px 6px; border-radius: 9999px; }
+  ::-webkit-scrollbar { width: 6px; }
+  ::-webkit-scrollbar-track { background: transparent; }
+  ::-webkit-scrollbar-thumb { background: #4c1d95; border-radius: 3px; }
+</style>
+</head>
+<body class="min-h-screen flex flex-col">
+<!-- Header -->
+<header class="border-b border-purple-900/30 px-6 py-3 flex items-center justify-between">
+  <div class="flex items-center gap-3">
+    <div class="text-2xl font-bold bg-gradient-to-r from-purple-400 to-cyan-400 bg-clip-text text-transparent">
+      ⚡ SYNAPSE
+    </div>
+    <span class="text-xs text-gray-500">v0.1.0</span>
+    <span id="status-dot" class="w-2 h-2 rounded-full bg-green-500 pulse"></span>
+  </div>
+  <div class="flex items-center gap-4 text-xs text-gray-400">
+    <span id="model-info">Loading...</span>
+    <button onclick="showPanel('stats')" class="hover:text-purple-400 transition">📊 Stats</button>
+    <button onclick="showPanel('confidence')" class="hover:text-purple-400 transition">🧠 Brain</button>
+  </div>
+</header>
+<!-- Main content -->
+<div class="flex flex-1 overflow-hidden">
+  <!-- Chat area -->
+  <main class="flex-1 flex flex-col">
+    <!-- Messages -->
+    <div id="messages" class="flex-1 overflow-y-auto px-6 py-4 space-y-4">
+      <div class="text-center text-gray-500 mt-20">
+        <div class="text-4xl mb-3">🧠</div>
+        <div class="text-lg font-semibold">TITAN Synapse</div>
+        <div class="text-sm mt-1">Small models that think together. And learn.</div>
+        <div class="text-xs mt-2 text-gray-600">Every conversation makes me smarter.</div>
+      </div>
+    </div>
+    <!-- Input -->
+    <div class="border-t border-purple-900/30 px-6 py-4">
+      <form onsubmit="sendMessage(event)" class="flex gap-3">
+        <input id="chat-input" type="text" placeholder="Ask me anything..."
+          class="flex-1 bg-gray-900/50 border border-purple-900/30 rounded-xl px-4 py-3 text-sm
+                 outline-none transition placeholder-gray-600" autocomplete="off">
+        <button type="submit" id="send-btn"
+          class="bg-purple-600 hover:bg-purple-500 px-6 py-3 rounded-xl text-sm font-medium transition">
+          Send
+        </button>
+      </form>
+      <div class="flex items-center gap-4 mt-2 text-xs text-gray-500">
+        <span id="typing-indicator" class="hidden text-purple-400">⚡ Thinking...</span>
+        <span id="tok-speed" class="ml-auto"></span>
+      </div>
+    </div>
+  </main>
+  <!-- Side panel -->
+  <aside id="side-panel" class="hidden w-80 border-l border-purple-900/30 overflow-y-auto p-4">
+    <div id="panel-content"></div>
+  </aside>
+</div>
+<script>
+const API = window.location.origin;
+let messageHistory = [];
+async function sendMessage(e) {
+  e.preventDefault();
+  const input = document.getElementById('chat-input');
+  const msg = input.value.trim();
+  if (!msg) return;
+  input.value = '';
+  addMessage('user', msg);
+  messageHistory.push({ role: 'user', content: msg });
+  const typing = document.getElementById('typing-indicator');
+  const speedEl = document.getElementById('tok-speed');
+  typing.classList.remove('hidden');
+  document.getElementById('send-btn').disabled = true;
+  const start = performance.now();
+  try {
+    const resp = await fetch(API + '/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: 'synapse',
+        messages: messageHistory.slice(-10), // Last 10 messages for context
+        max_tokens: 2048,
+        temperature: 0.7,
+      }),
+    });
+    const data = await resp.json();
+    const elapsed = ((performance.now() - start) / 1000).toFixed(1);
+    const content = data.choices?.[0]?.message?.content || 'Error: No response';
+    const usage = data.usage || {};
+    addMessage('assistant', content, usage);
+    messageHistory.push({ role: 'assistant', content });
+    const tokPerSec = usage.completion_tokens
+      ? (usage.completion_tokens / parseFloat(elapsed)).toFixed(0)
+      : '?';
+    speedEl.textContent = `${usage.completion_tokens || '?'} tokens · ${elapsed}s · ${tokPerSec} tok/s`;
+  } catch (err) {
+    addMessage('assistant', `Connection error: ${err.message}. Is the server running?`);
+  }
+  typing.classList.add('hidden');
+  document.getElementById('send-btn').disabled = false;
+}
+function addMessage(role, content, usage) {
+  const container = document.getElementById('messages');
+  // Remove welcome message on first real message
+  if (messageHistory.length <= 1 && role === 'user') {
+    container.innerHTML = '';
+  }
+  const div = document.createElement('div');
+  div.className = `rounded-xl px-4 py-3 max-w-3xl ${role === 'user' ? 'msg-user ml-auto' : 'msg-ai'}`;
+  const label = document.createElement('div');
+  label.className = 'text-xs font-semibold mb-1 ' + (role === 'user' ? 'text-purple-300' : 'text-cyan-300');
+  label.textContent = role === 'user' ? 'You' : 'Synapse';
+  if (usage && usage.prompt_tokens) {
+    const badge = document.createElement('span');
+    badge.className = 'specialist-tag bg-purple-900/50 text-purple-300 ml-2';
+    badge.textContent = `${usage.prompt_tokens}→${usage.completion_tokens} tokens`;
+    label.appendChild(badge);
+  }
+  const text = document.createElement('div');
+  text.className = 'text-sm leading-relaxed whitespace-pre-wrap';
+  // Simple markdown-like formatting
+  text.innerHTML = formatContent(content);
+  div.appendChild(label);
+  div.appendChild(text);
+  container.appendChild(div);
+  container.scrollTop = container.scrollHeight;
+}
+function formatContent(text) {
+  // Code blocks
+  text = text.replace(/```(\w*)\n([\s\S]*?)```/g,
+    '<pre class="bg-black/40 rounded-lg p-3 my-2 overflow-x-auto text-xs"><code>$2</code></pre>');
+  // Inline code
+  text = text.replace(/`([^`]+)`/g, '<code class="bg-black/30 px-1 rounded text-purple-300">$1</code>');
+  // Bold
+  text = text.replace(/\*\*([^*]+)\*\*/g, '<strong class="text-white">$1</strong>');
+  // Lists
+  text = text.replace(/^(\d+)\. /gm, '<span class="text-purple-400">$1.</span> ');
+  text = text.replace(/^- /gm, '<span class="text-cyan-400">•</span> ');
+  return text;
+}
+async function showPanel(type) {
+  const panel = document.getElementById('side-panel');
+  const content = document.getElementById('panel-content');
+  panel.classList.toggle('hidden');
+  if (type === 'stats') {
+    content.innerHTML = '<div class="text-center text-gray-500">Loading...</div>';
+    try {
+      const resp = await fetch(API + '/api/status');
+      const data = await resp.json();
+      content.innerHTML = `
+        <h3 class="text-sm font-bold text-purple-300 mb-3">📊 System Status</h3>
+        <div class="space-y-2 text-xs">
+          <div class="flex justify-between"><span class="text-gray-400">Version</span><span>${data.version}</span></div>
+          <div class="flex justify-between"><span class="text-gray-400">Models</span><span>${data.models_loaded?.length || 0}</span></div>
+          <div class="flex justify-between"><span class="text-gray-400">Specialists</span><span>${data.specialists?.length || 0}</span></div>
+          <div class="flex justify-between"><span class="text-gray-400">Adapters</span><span>${data.adapters?.length || 0}</span></div>
+          <hr class="border-purple-900/30 my-2">
+          <h4 class="font-semibold text-cyan-300">Knowledge Graph</h4>
+          <div class="flex justify-between"><span class="text-gray-400">Facts known</span><span>${data.knowledge?.facts || 0}</span></div>
+          <div class="flex justify-between"><span class="text-gray-400">Conversations</span><span>${data.knowledge?.conversations || 0}</span></div>
+          <div class="flex justify-between"><span class="text-gray-400">Preference pairs</span><span>${data.knowledge?.preference_pairs || 0}</span></div>
+          <hr class="border-purple-900/30 my-2">
+          <h4 class="font-semibold text-cyan-300">Loaded Models</h4>
+          ${(data.models_loaded || []).map(m => `<div class="text-gray-300">• ${m}</div>`).join('')}
+          <hr class="border-purple-900/30 my-2">
+          <h4 class="font-semibold text-cyan-300">Hebbian Pathways</h4>
+          ${(data.hebbian_routing?.top_pathways || []).map(p =>
+            `<div class="flex justify-between"><span class="text-gray-400">${p.pathway}</span><span>×${p.strength}</span></div>`
+          ).join('')}
+        </div>
+      `;
+    } catch (e) {
+      content.innerHTML = '<div class="text-red-400 text-xs">Failed to load status</div>';
+    }
+  } else if (type === 'confidence') {
+    content.innerHTML = '<div class="text-center text-gray-500">Loading...</div>';
+    try {
+      const resp = await fetch(API + '/api/confidence');
+      const data = await resp.json();
+      const m = data.metacognition;
+      content.innerHTML = `
+        <h3 class="text-sm font-bold text-purple-300 mb-3">🧠 Metacognition</h3>
+        <p class="text-xs text-gray-400 mb-3">What the system knows about itself</p>
+        <div class="space-y-3">
+          <h4 class="font-semibold text-cyan-300 text-xs">Specialist Confidence</h4>
+          ${(m.specialists || []).map(s => `
+            <div class="bg-gray-900/50 rounded-lg p-2 text-xs">
+              <div class="flex justify-between font-medium">
+                <span>${s.specialist}</span>
+                <span class="text-purple-300">${s.avg_tok_per_sec?.toFixed(0)} tok/s</span>
+              </div>
+              <div class="flex justify-between text-gray-500 mt-1">
+                <span>${s.requests} requests</span>
+                <span>score: ${s.avg_score?.toFixed(1)}/5</span>
+              </div>
+              <div class="w-full bg-gray-800 rounded-full h-1 mt-1">
+                <div class="bg-purple-500 h-1 rounded-full" style="width: ${(s.avg_score/5*100)}%"></div>
+              </div>
+            </div>
+          `).join('')}
+          <hr class="border-purple-900/30">
+          <h4 class="font-semibold text-cyan-300 text-xs">Learning Status</h4>
+          <div class="text-xs space-y-1">
+            <div class="flex justify-between"><span class="text-gray-400">Facts learned</span><span>${m.learning_status?.facts_known || 0}</span></div>
+            <div class="flex justify-between"><span class="text-gray-400">Conversations</span><span>${m.learning_status?.conversations_logged || 0}</span></div>
+            <div class="flex justify-between"><span class="text-gray-400">Preferences</span><span>${m.learning_status?.preferences_collected || 0}</span></div>
+          </div>
+        </div>
+      `;
+    } catch (e) {
+      content.innerHTML = '<div class="text-red-400 text-xs">Failed to load confidence data</div>';
+    }
+  }
+}
+// Load initial status
+async function init() {
+  try {
+    const resp = await fetch(API + '/api/status');
+    const data = await resp.json();
+    document.getElementById('model-info').textContent =
+      `${data.models_loaded?.length || 0} models · ${data.specialists?.length || 0} specialists · ${data.knowledge?.facts || 0} facts`;
+  } catch (e) {
+    document.getElementById('model-info').textContent = 'Disconnected';
+    document.getElementById('status-dot').className = 'w-2 h-2 rounded-full bg-red-500';
+  }
+}
+// Allow Enter to send, Shift+Enter for newline
+document.getElementById('chat-input').addEventListener('keydown', (e) => {
+  if (e.key === 'Enter' && !e.shiftKey) {
+    e.preventDefault();
+    document.querySelector('form').dispatchEvent(new Event('submit'));
+  }
+});
+init();
+</script>
+</body>
+</html>"#;

package/crates/synapse/src/format/manifest.rs ADDED Viewed

@@ -0,0 +1,57 @@
+use serde::{Deserialize, Serialize};
+/// Manifest for .synapse model format
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SynapseManifest {
+    pub format: String,
+    pub version: String,
+    pub name: String,
+    pub base_model: String,
+    pub base_quantization: String,
+    pub vram_estimate_mb: u64,
+    pub capabilities: Vec<String>,
+    pub adapter_count: u32,
+    pub training_pairs_collected: u32,
+    pub last_trained: Option<String>,
+    pub performance_score: f32,
+    pub created_by: String,
+}
+impl SynapseManifest {
+    pub fn new(name: &str, base_model: &str) -> Self {
+        Self {
+            format: "synapse".into(),
+            version: env!("CARGO_PKG_VERSION").into(),
+            name: name.into(),
+            base_model: base_model.into(),
+            base_quantization: "Q4_K_M".into(),
+            vram_estimate_mb: 2100,
+            capabilities: vec![],
+            adapter_count: 0,
+            training_pairs_collected: 0,
+            last_trained: None,
+            performance_score: 0.0,
+            created_by: format!("titan-synapse/{}", env!("CARGO_PKG_VERSION")),
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_manifest_creation() {
+        let m = SynapseManifest::new("python_expert", "Qwen3-3B");
+        assert_eq!(m.format, "synapse");
+        assert_eq!(m.name, "python_expert");
+    }
+    #[test]
+    fn test_manifest_serialization() {
+        let m = SynapseManifest::new("test", "Qwen3-3B");
+        let json = serde_json::to_string_pretty(&m).unwrap();
+        let parsed: SynapseManifest = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.name, "test");
+    }
+}

package/crates/synapse/src/format/mod.rs ADDED Viewed

@@ -0,0 +1,4 @@
+pub mod manifest;
+pub mod packer;
+pub use manifest::SynapseManifest;

package/crates/synapse/src/format/packer.rs ADDED Viewed

@@ -0,0 +1,213 @@
+use anyhow::Result;
+use std::path::{Path, PathBuf};
+use super::manifest::SynapseManifest;
+/// Pack a specialist into a .synapse directory bundle
+///
+/// Layout:
+///   <name>.synapse/
+///     manifest.json
+///     model.gguf (if found)
+///     adapters/*.safetensors
+///     knowledge/graph.sqlite
+///     agent.yaml
+pub fn pack(
+    manifest: &SynapseManifest,
+    models_dir: &Path,
+    adapters_dir: &Path,
+    knowledge_db: Option<&Path>,
+    output_path: &Path,
+) -> Result<()> {
+    std::fs::create_dir_all(output_path)?;
+    // Write manifest
+    let manifest_json = serde_json::to_string_pretty(manifest)?;
+    std::fs::write(output_path.join("manifest.json"), manifest_json)?;
+    // Copy model GGUF if found
+    let model_glob = format!("{}*", manifest.name);
+    if let Ok(entries) = std::fs::read_dir(models_dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.extension().is_some_and(|ext| ext == "gguf") {
+                let dest = output_path.join("model.gguf");
+                // Symlink instead of copy (saves disk space for multi-GB files)
+                #[cfg(unix)]
+                {
+                    if let Err(_) = std::os::unix::fs::symlink(&path, &dest) {
+                        std::fs::copy(&path, &dest)?;
+                    }
+                }
+                #[cfg(not(unix))]
+                {
+                    std::fs::copy(&path, &dest)?;
+                }
+                tracing::info!("Linked model: {}", path.display());
+                break;
+            }
+        }
+    }
+    // Copy adapters
+    let adapters_out = output_path.join("adapters");
+    std::fs::create_dir_all(&adapters_out)?;
+    let mut adapter_count = 0u32;
+    if adapters_dir.exists() {
+        for entry in std::fs::read_dir(adapters_dir)?.flatten() {
+            let path = entry.path();
+            if path.extension().is_some_and(|ext| ext == "safetensors") {
+                let name = path.file_name().unwrap();
+                std::fs::copy(&path, adapters_out.join(name))?;
+                adapter_count += 1;
+            }
+        }
+    }
+    // Copy knowledge graph
+    if let Some(db_path) = knowledge_db {
+        if db_path.exists() {
+            let knowledge_out = output_path.join("knowledge");
+            std::fs::create_dir_all(&knowledge_out)?;
+            std::fs::copy(db_path, knowledge_out.join("graph.sqlite"))?;
+        }
+    }
+    tracing::info!(
+        "Packed specialist '{}': {} adapters, output: {}",
+        manifest.name,
+        adapter_count,
+        output_path.display()
+    );
+    Ok(())
+}
+/// Unpack a .synapse directory bundle into the working directories
+pub fn unpack(
+    synapse_path: &Path,
+    models_dir: &Path,
+    adapters_dir: &Path,
+) -> Result<SynapseManifest> {
+    if !synapse_path.exists() {
+        anyhow::bail!("Path does not exist: {}", synapse_path.display());
+    }
+    let manifest_path = synapse_path.join("manifest.json");
+    if !manifest_path.exists() {
+        anyhow::bail!("No manifest.json found in {}", synapse_path.display());
+    }
+    let content = std::fs::read_to_string(&manifest_path)?;
+    let manifest: SynapseManifest = serde_json::from_str(&content)?;
+    // Copy model if present
+    let model_file = synapse_path.join("model.gguf");
+    if model_file.exists() {
+        std::fs::create_dir_all(models_dir)?;
+        let dest = models_dir.join(format!("{}.gguf", manifest.name));
+        if !dest.exists() {
+            std::fs::copy(&model_file, &dest)?;
+            tracing::info!("Installed model: {}", dest.display());
+        }
+    }
+    // Copy adapters
+    let adapters_src = synapse_path.join("adapters");
+    if adapters_src.exists() {
+        std::fs::create_dir_all(adapters_dir)?;
+        for entry in std::fs::read_dir(&adapters_src)?.flatten() {
+            let path = entry.path();
+            if path.extension().is_some_and(|ext| ext == "safetensors") {
+                let name = path.file_name().unwrap();
+                let dest = adapters_dir.join(name);
+                std::fs::copy(&path, &dest)?;
+            }
+        }
+    }
+    // Copy knowledge graph
+    let knowledge_src = synapse_path.join("knowledge").join("graph.sqlite");
+    if knowledge_src.exists() {
+        let knowledge_dir = synapse_path.parent()
+            .unwrap_or(Path::new("."))
+            .join("knowledge");
+        std::fs::create_dir_all(&knowledge_dir)?;
+        std::fs::copy(&knowledge_src, knowledge_dir.join("graph.sqlite"))?;
+    }
+    tracing::info!("Unpacked specialist '{}' (base: {})", manifest.name, manifest.base_model);
+    Ok(manifest)
+}
+/// List all .synapse bundles in a directory
+pub fn list_bundles(dir: &Path) -> Result<Vec<(PathBuf, SynapseManifest)>> {
+    let mut bundles = Vec::new();
+    if !dir.exists() {
+        return Ok(bundles);
+    }
+    for entry in std::fs::read_dir(dir)?.flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            let manifest_path = path.join("manifest.json");
+            if manifest_path.exists() {
+                if let Ok(content) = std::fs::read_to_string(&manifest_path) {
+                    if let Ok(manifest) = serde_json::from_str::<SynapseManifest>(&content) {
+                        bundles.push((path, manifest));
+                    }
+                }
+            }
+        }
+    }
+    Ok(bundles)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_pack_and_unpack() {
+        let tmp = tempfile::tempdir().unwrap();
+        let models_dir = tmp.path().join("models");
+        let adapters_dir = tmp.path().join("adapters");
+        let output = tmp.path().join("test_specialist.synapse");
+        std::fs::create_dir_all(&models_dir).unwrap();
+        std::fs::create_dir_all(&adapters_dir).unwrap();
+        let manifest = SynapseManifest::new("test_specialist", "Qwen3-3B");
+        // Pack
+        pack(&manifest, &models_dir, &adapters_dir, None, &output).unwrap();
+        assert!(output.join("manifest.json").exists());
+        // Unpack into new dirs
+        let new_models = tmp.path().join("new_models");
+        let new_adapters = tmp.path().join("new_adapters");
+        let unpacked = unpack(&output, &new_models, &new_adapters).unwrap();
+        assert_eq!(unpacked.name, "test_specialist");
+        assert_eq!(unpacked.base_model, "Qwen3-3B");
+    }
+    #[test]
+    fn test_list_bundles() {
+        let tmp = tempfile::tempdir().unwrap();
+        // Create two bundles
+        for name in ["alpha", "beta"] {
+            let bundle_dir = tmp.path().join(format!("{name}.synapse"));
+            std::fs::create_dir_all(&bundle_dir).unwrap();
+            let manifest = SynapseManifest::new(name, "Qwen3-3B");
+            std::fs::write(
+                bundle_dir.join("manifest.json"),
+                serde_json::to_string(&manifest).unwrap(),
+            ).unwrap();
+        }
+        let bundles = list_bundles(tmp.path()).unwrap();
+        assert_eq!(bundles.len(), 2);
+    }
+}