@techwavedev/agi-agent-kit 1.6.3 → 1.6.5

package/templates/base/execution/memory_manager.py

@@ -58,26 +58,7 @@ sys.path.insert(0, SKILL_SCRIPTS_DIR)
 
 from embedding_utils import check_embedding_service, get_embedding_dimension
 from semantic_cache import check_cache, store_response, clear_cache
-from memory_retrieval import retrieve_context, store_memory, list_memories, build_filter, resolve_developer_id, resolve_agent_id
-
-# Import blockchain auth (optional — graceful if unavailable)
-try:
-    from blockchain_auth import (
-        sign_content, anchor_hash, verify_hash, check_access,
-        health_check as blockchain_health, content_hash
-    )
-    _BLOCKCHAIN_AVAILABLE = True
-except ImportError:
-    _BLOCKCHAIN_AVAILABLE = False
-
-# Import agent events (optional — graceful if unavailable)
-try:
-    from agent_events import (
-        publish_event, health_check as pulsar_health
-    )
-    _EVENTS_AVAILABLE = True
-except ImportError:
-    _EVENTS_AVAILABLE = False
+from memory_retrieval import retrieve_context, store_memory, list_memories, build_filter
 
 # Import BM25 index (optional — graceful if unavailable)
 try:
@@ -89,20 +70,10 @@ except ImportError:
 # Configuration
 QDRANT_URL = os.environ.get("QDRANT_URL", "http://localhost:6333")
 
-# ═══════════════════════════════════════════════════════════════
-# Memory Mode — controls feature tiers
-# ═══════════════════════════════════════════════════════════════
-# solo  = Ollama + Qdrant only (single developer, no identity, no blockchain)
-# team  = + Multi-tenancy (developer/agent identity tagging, shared memory)
-# pro   = + Blockchain auth (signed writes, hash anchoring, access control)
-MEMORY_MODE = os.environ.get("MEMORY_MODE", "team").lower()
-_TEAM_FEATURES = MEMORY_MODE in ("team", "pro")
-_PRO_FEATURES = MEMORY_MODE == "pro" and _BLOCKCHAIN_AVAILABLE
-
 
 def health_check() -> dict:
     """Check Qdrant connectivity and embedding service status."""
-    result = {"qdrant": "unknown", "embeddings": "unknown", "collections": [], "memory_mode": MEMORY_MODE}
+    result = {"qdrant": "unknown", "embeddings": "unknown", "collections": []}
 
     # Check Qdrant
     try:
@@ -150,23 +121,6 @@ def health_check() -> dict:
         and len(result["missing_collections"]) == 0
     )
 
-    # Check blockchain (pro mode only)
-    if _PRO_FEATURES:
-        try:
-            bc = blockchain_health()
-            result["blockchain"] = bc
-        except Exception:
-            result["blockchain"] = {"status": "not_available"}
-    elif MEMORY_MODE == "pro":
-        result["blockchain"] = {"status": "module_not_loaded"}
-
-    # Check Pulsar events (team/pro — optional)
-    if _EVENTS_AVAILABLE and _TEAM_FEATURES:
-        try:
-            result["events"] = pulsar_health()
-        except Exception:
-            result["events"] = {"status": "not_available", "optional": True}
-
     return result
 
 
@@ -175,9 +129,7 @@ def auto_query(
     project: str = None, 
     threshold: float = 0.92,
     vector_weight: float = None,
-    text_weight: float = None,
-    developer: str = None,
-    shared_only: bool = False
+    text_weight: float = None
 ) -> dict:
     """
     Smart query: check cache first, then retrieve context using Hybrid Search.
@@ -193,8 +145,7 @@ def auto_query(
         "cache_hit": False,
         "context_chunks": [],
         "tokens_saved_estimate": 0,
-        "search_type": "hybrid",
-        "developer_id": developer or resolve_developer_id()
+        "search_type": "hybrid"
     }
 
     # Step 1: Semantic cache check
@@ -212,22 +163,9 @@ def auto_query(
 
     # Step 2: Context retrieval
     try:
-        # Build identity-aware filter
-        filter_conditions = []
+        filters = None
         if project:
-            filter_conditions.append({"key": "project", "match": {"value": project}})
-        if shared_only:
-            filter_conditions.append({"key": "shared", "match": {"value": True}})
-        elif developer:
-            # If not shared-only, filter by developer (own + shared)
-            filter_conditions.append({
-                "should": [
-                    {"key": "developer_id", "match": {"value": developer}},
-                    {"key": "shared", "match": {"value": True}}
-                ]
-            })
-
-        filters = {"must": filter_conditions} if filter_conditions else None
+            filters = {"must": [{"key": "project", "match": {"value": project}}]}
 
         context = retrieve_context(
             query, 
@@ -278,8 +216,6 @@ Examples:
     )
     auto_parser.add_argument("--vector-weight", type=float, help="Hybrid search vector weight")
     auto_parser.add_argument("--text-weight", type=float, help="Hybrid search text weight")
-    auto_parser.add_argument("--developer", help="Filter by developer ID (default: auto-detect)")
-    auto_parser.add_argument("--shared-only", action="store_true", help="Only retrieve shared memories")
 
     # Store command
     store_parser = subparsers.add_parser(
@@ -294,11 +230,6 @@ Examples:
     )
     store_parser.add_argument("--project", help="Project name")
     store_parser.add_argument("--tags", nargs="+", help="Tags for the memory")
-    store_parser.add_argument("--developer", help="Override developer ID")
-    store_parser.add_argument("--agent", help="Override agent ID")
-    store_parser.add_argument("--shared", action="store_true", help="Mark as team-visible (shared) memory")
-    store_parser.add_argument("--auth", action="store_true", help="Sign content and anchor hash on blockchain")
-    store_parser.add_argument("--verify", action="store_true", help="Verify content hash after store")
 
     # Retrieve command
     retrieve_parser = subparsers.add_parser(
@@ -315,11 +246,6 @@ Examples:
     )
     retrieve_parser.add_argument("--vector-weight", type=float, help="Hybrid search vector weight")
     retrieve_parser.add_argument("--text-weight", type=float, help="Hybrid search text weight")
-    retrieve_parser.add_argument("--developer", help="Filter by developer ID")
-    retrieve_parser.add_argument("--agent", help="Filter by agent ID")
-    retrieve_parser.add_argument("--shared-only", action="store_true", help="Only retrieve shared memories")
-    retrieve_parser.add_argument("--auth", action="store_true", help="Enforce blockchain access check before retrieve")
-    retrieve_parser.add_argument("--verify", action="store_true", help="Verify content hashes after retrieve")
 
     # Cache store command
     cache_parser = subparsers.add_parser(
@@ -334,8 +260,6 @@ Examples:
     list_parser = subparsers.add_parser("list", help="List stored memories")
     list_parser.add_argument("--type", help="Filter by memory type")
     list_parser.add_argument("--project", help="Filter by project")
-    list_parser.add_argument("--developer", help="Filter by developer ID")
-    list_parser.add_argument("--shared-only", action="store_true", help="Only list shared memories")
     list_parser.add_argument("--limit", type=int, default=20, help="Max results")
 
     # Health command
@@ -361,9 +285,7 @@ Examples:
                 args.project, 
                 args.threshold,
                 vector_weight=args.vector_weight,
-                text_weight=args.text_weight,
-                developer=args.developer,
-                shared_only=getattr(args, "shared_only", False)
+                text_weight=args.text_weight
             )
             print(json.dumps(result, indent=2))
             sys.exit(0 if result["source"] != "none" else 1)
@@ -374,64 +296,13 @@ Examples:
                 metadata["project"] = args.project
             if args.tags:
                 metadata["tags"] = args.tags
-            result = store_memory(
-                args.content, args.type, metadata,
-                shared=getattr(args, "shared", False) if _TEAM_FEATURES else False,
-                developer_id=getattr(args, "developer", None) if _TEAM_FEATURES else None,
-                agent_id=getattr(args, "agent", None) if _TEAM_FEATURES else None
-            )
-
-            # Blockchain: sign + anchor if --auth (pro mode only)
-            if getattr(args, "auth", False) and _PRO_FEATURES:
-                dev_id = getattr(args, "developer", None) or resolve_developer_id()
-                sig = sign_content(args.content)
-                result["signature"] = sig
-                anchor_result = anchor_hash(
-                    sig["content_hash"], dev_id,
-                    project=args.project
-                )
-                result["blockchain_anchor"] = anchor_result
-            elif getattr(args, "auth", False) and not _PRO_FEATURES:
-                result["blockchain_anchor"] = {
-                    "status": "disabled",
-                    "message": f"Blockchain auth requires MEMORY_MODE=pro (current: {MEMORY_MODE})",
-                    "graceful_degradation": True
-                }
-
-            # Publish event to Pulsar (team/pro — fire-and-forget)
-            if _EVENTS_AVAILABLE and _TEAM_FEATURES and args.project:
-                try:
-                    event_type = "decision_made" if args.type == "decision" else \
-                                 "code_written" if args.type == "code" else \
-                                 "error_resolved" if args.type == "error" else "memory_stored"
-                    evt = publish_event(
-                        project=args.project, event_type=event_type,
-                        content=args.content[:200],  # Truncate for event
-                        developer_id=getattr(args, "developer", None),
-                        agent_id=getattr(args, "agent", None)
-                    )
-                    result["event"] = evt
-                except Exception:
-                    result["event"] = {"status": "skipped", "reason": "Pulsar unavailable"}
-
+            result = store_memory(args.content, args.type, metadata)
             print(json.dumps(result, indent=2))
             sys.exit(0)
 
         elif args.command == "retrieve":
-            # Blockchain: check access before retrieve if --auth (pro mode only)
-            if getattr(args, "auth", False) and _PRO_FEATURES:
-                dev_id = getattr(args, "developer", None) or resolve_developer_id()
-                access = check_access(dev_id, args.project or "default", "read")
-                if not access.get("allowed", True):
-                    print(json.dumps(access, indent=2))
-                    sys.exit(3)
-
             filters = build_filter(
-                type_filter=getattr(args, "type", None),
-                project=args.project,
-                developer=getattr(args, "developer", None),
-                agent=getattr(args, "agent", None),
-                shared_only=getattr(args, "shared_only", False)
+                type_filter=getattr(args, "type", None), project=args.project
             )
             result = retrieve_context(
                 args.query,
@@ -454,10 +325,7 @@ Examples:
 
         elif args.command == "list":
             filters = build_filter(
-                type_filter=getattr(args, "type", None),
-                project=args.project,
-                developer=getattr(args, "developer", None),
-                shared_only=getattr(args, "shared_only", False)
+                type_filter=getattr(args, "type", None), project=args.project
             )
             result = list_memories(
                 filters={"must": filters["must"]} if filters else None, limit=args.limit

package/templates/base/execution/run_test_scenario.py

@@ -15,8 +15,8 @@ Usage:
     python3 execution/run_test_scenario.py --all --verbose
 
 Arguments:
-    --scenario  Scenario number to run (1-10)
-    --all       Run all 10 scenarios
+    --scenario  Scenario number to run (1-6)
+    --all       Run all 6 scenarios
     --verbose   Show detailed output for each step
     --dry-run   Validate setup without dispatching agents
 
@@ -75,7 +75,7 @@ def validate_setup(root: Path) -> dict:
     checks = {}
 
     # Execution scripts
-    for script in ["dispatch_agent_team.py", "agent_team_result.py", "test_qdrant_handoff.py"]:
+    for script in ["dispatch_agent_team.py", "agent_team_result.py"]:
         path = root / "execution" / script
         checks[f"script:{script}"] = path.exists()
 
@@ -412,102 +412,6 @@ def scenario_6_dynamic_handoff(root: Path, verbose: bool, dry_run: bool) -> dict
 
 # ─── RUNNER ───────────────────────────────────────────────────────────────────
 
-def scenario_7_qdrant_store_retrieve(root: Path, verbose: bool, dry_run: bool) -> dict:
-    """
-    Scenario 7: Qdrant Store/Retrieve Round-Trip
-    Pattern: qdrant-memory-fidelity
-    Validates: content stored by an agent can be retrieved verbatim (baseline memory test).
-    Delegates to test_qdrant_handoff.py --suite 1
-    """
-    return _run_qdrant_handoff_suite(root, suite=1, verbose=verbose, dry_run=dry_run,
-                                     scenario_id="scenario_07_qdrant_store_retrieve",
-                                     pattern="qdrant-memory-fidelity")
-
-
-def scenario_8_handoff_persistence(root: Path, verbose: bool, dry_run: bool) -> dict:
-    """
-    Scenario 8: Cross-Subagent Handoff Persistence
-    Pattern: cross-agent-handoff
-    Validates: Agent A stores handoff_state; Agent B retrieves it with all required
-               fields (state, next_steps, validation_requirements) intact.
-    Delegates to test_qdrant_handoff.py --suite 2
-    """
-    return _run_qdrant_handoff_suite(root, suite=2, verbose=verbose, dry_run=dry_run,
-                                     scenario_id="scenario_08_handoff_persistence",
-                                     pattern="cross-agent-handoff")
-
-
-def scenario_9_parallel_memory_isolation(root: Path, verbose: bool, dry_run: bool) -> dict:
-    """
-    Scenario 9: Parallel Subagent Memory Isolation
-    Pattern: parallel-memory-isolation
-    Validates: two parallel subagents store to Qdrant without point-ID collision and
-               each agent's query returns its own data.
-    Delegates to test_qdrant_handoff.py --suite 3
-    """
-    return _run_qdrant_handoff_suite(root, suite=3, verbose=verbose, dry_run=dry_run,
-                                     scenario_id="scenario_09_parallel_memory_isolation",
-                                     pattern="parallel-memory-isolation")
-
-
-def scenario_10_memory_guided_routing(root: Path, verbose: bool, dry_run: bool) -> dict:
-    """
-    Scenario 10: Memory-Guided Orchestrator Routing
-    Pattern: memory-guided-routing
-    Validates: orchestrator stores a routing decision in Qdrant, later retrieves it,
-               and dispatches the correct next team based on the retrieved context.
-    Delegates to test_qdrant_handoff.py --suite 4
-    """
-    return _run_qdrant_handoff_suite(root, suite=4, verbose=verbose, dry_run=dry_run,
-                                     scenario_id="scenario_10_memory_guided_routing",
-                                     pattern="memory-guided-routing")
-
-
-def _run_qdrant_handoff_suite(root: Path, suite: int, verbose: bool, dry_run: bool,
-                               scenario_id: str, pattern: str) -> dict:
-    """
-    Delegate helper: invokes test_qdrant_handoff.py --suite N and wraps the result
-    in the standard scenario format expected by the main runner.
-    """
-    handoff_script = root / "execution" / "test_qdrant_handoff.py"
-    if not handoff_script.exists():
-        return {
-            "scenario": scenario_id,
-            "pattern": pattern,
-            "status": "fail",
-            "steps": [{
-                "step": "locate test_qdrant_handoff.py",
-                "pass": False,
-                "error": f"Script not found: {handoff_script}",
-            }],
-        }
-
-    args = ["--suite", str(suite)]
-    if verbose:
-        args.append("--verbose")
-    if dry_run:
-        args.append("--dry-run")
-
-    result = run_script(root, "test_qdrant_handoff.py", args, verbose)
-    suite_data = result["output"]
-
-    # Flatten suite steps into the scenario's steps list
-    steps = suite_data.get("suites", [{}])[0].get("steps", []) if suite_data.get("suites") else []
-    steps.insert(0, {
-        "step": f"invoke test_qdrant_handoff.py --suite {suite}",
-        "exit_code": result["exit_code"],
-        "elapsed_s": result["elapsed_s"],
-    })
-
-    overall_status = suite_data.get("overall_status", "fail") if result["exit_code"] == 0 else "fail"
-    return {
-        "scenario": scenario_id,
-        "pattern": pattern,
-        "status": overall_status,
-        "steps": steps,
-    }
-
-
 SCENARIOS = {
     1: scenario_1_single_subagent,
     2: scenario_2_parallel_subagents,
@@ -515,17 +419,13 @@ SCENARIOS = {
     4: scenario_4_full_pipeline,
     5: scenario_5_failure_recovery,
     6: scenario_6_dynamic_handoff,
-    7: scenario_7_qdrant_store_retrieve,
-    8: scenario_8_handoff_persistence,
-    9: scenario_9_parallel_memory_isolation,
-    10: scenario_10_memory_guided_routing,
 }
 
 
 def main():
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    parser.add_argument("--scenario", type=int, choices=range(1, 11), help="Scenario number (1-10)")
-    parser.add_argument("--all", action="store_true", help="Run all 10 scenarios")
+    parser.add_argument("--scenario", type=int, choices=range(1, 7), help="Scenario number (1-6)")
+    parser.add_argument("--all", action="store_true", help="Run all 6 scenarios")
     parser.add_argument("--verbose", action="store_true", help="Show detailed step output")
     parser.add_argument("--dry-run", action="store_true", help="Validate setup without dispatching")
     args = parser.parse_args()
@@ -538,10 +438,7 @@ def main():
 
     # Validate setup first
     setup = validate_setup(root)
-    qdrant_scenarios = {7, 8, 9, 10}
-    selected = set(list(SCENARIOS.keys()) if args.all else [args.scenario])
-    needs_qdrant = bool(selected & qdrant_scenarios)
-    if not setup["pass"] and not (needs_qdrant and selected == selected & qdrant_scenarios):
+    if not setup["pass"]:
         missing = [k for k, v in setup["checks"].items() if not v]
         print(json.dumps({
             "status": "setup_failed",

package/templates/base/execution/session_boot.py

@@ -36,8 +36,6 @@ QDRANT_URL = os.environ.get("QDRANT_URL", "http://localhost:6333")
 OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434")
 EMBEDDING_MODEL = "nomic-embed-text"
 PROJECT_DIR = Path(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-MEMORY_MODE = os.environ.get("MEMORY_MODE", "team").lower()
-MODE_LABELS = {"solo": "Solo (Ollama+Qdrant)", "team": "Team (multi-tenancy)", "pro": "Pro (blockchain auth)"}
 
 
 def check_qdrant() -> dict:
@@ -83,41 +81,6 @@ def check_ollama() -> dict:
     return result
 
 
-def check_blockchain() -> dict:
-    """Check Aries (ACA-Py) connectivity (optional — does not affect readiness)."""
-    result = {"status": "not_running", "optional": True, "agent": "ACA-Py (Hyperledger Aries)"}
-    try:
-        aries_url = os.environ.get("ARIES_ADMIN_URL", "http://localhost:8031")
-        aries_key = os.environ.get("ARIES_ADMIN_KEY", "changeme_set_in_dotenv")
-        req = Request(
-            f"{aries_url}/status",
-            headers={"X-API-Key": aries_key},
-            method="GET"
-        )
-        with urlopen(req, timeout=5) as response:
-            data = json.loads(response.read().decode())
-            result["status"] = "ok"
-            result["version"] = data.get("version", "unknown")
-            result["label"] = data.get("label", "unknown")
-    except Exception:
-        pass
-    return result
-
-
-def check_pulsar() -> dict:
-    """Check Apache Pulsar connectivity (optional)."""
-    result = {"status": "not_running", "optional": True}
-    try:
-        pulsar_url = os.environ.get("PULSAR_HTTP_URL", "http://localhost:8080")
-        req = Request(f"{pulsar_url}/admin/v2/brokers/healthcheck", method="GET")
-        with urlopen(req, timeout=5) as resp:
-            if resp.status == 200:
-                result["status"] = "ok"
-    except Exception:
-        pass
-    return result
-
-
 def run_session_init() -> bool:
     """Run session_init.py to create collections."""
     init_script = PROJECT_DIR / "execution" / "session_init.py"
@@ -186,7 +149,6 @@ def main():
     report = {
         "qdrant": {},
         "ollama": {},
-        "blockchain": {},
         "memory_ready": False,
         "actions_taken": [],
         "issues": [],
@@ -245,33 +207,6 @@ def main():
             else:
                 report["issues"].append("Collections missing. Run: python3 execution/session_init.py")
 
-    # Step 4: Check blockchain (optional — does not affect readiness)
-    blockchain = check_blockchain()
-    report["blockchain"] = blockchain
-
-    # Step 5: Check Pulsar (optional — does not affect readiness)
-    pulsar = check_pulsar()
-    report["pulsar"] = pulsar
-
-    # Step 6: Auto-sync BM25 index from shared Qdrant (ensures keyword search works on every machine)
-    bm25_result = {"status": "skipped"}
-    if report.get("qdrant", {}).get("status") == "ok":
-        try:
-            import subprocess
-            bm25_script = PROJECT_DIR / "execution" / "memory_manager.py"
-            proc = subprocess.run(
-                ["python3", str(bm25_script), "bm25-sync"],
-                capture_output=True, text=True, timeout=60,
-                cwd=str(PROJECT_DIR)
-            )
-            if proc.returncode == 0:
-                import json as _json
-                bm25_result = _json.loads(proc.stdout)
-            else:
-                bm25_result = {"status": "error", "message": proc.stderr[:200]}
-        except Exception as e:
-            bm25_result = {"status": "error", "message": str(e)}
-    report["bm25_sync"] = bm25_result
     # Step 4: Register with Control Tower (best-effort)
     try:
         from control_tower import register_agent
@@ -303,8 +238,6 @@ def main():
     )
     report["summary"] = {
         "ready": report["memory_ready"],
-        "memory_mode": MEMORY_MODE,
-        "mode_label": MODE_LABELS.get(MEMORY_MODE, MEMORY_MODE),
         "total_memories": agent_mem.get("points", 0),
         "total_cached": sem_cache.get("points", 0),
         "agent_id": identity.get("agent_id"),
@@ -316,22 +249,7 @@ def main():
         if report["memory_ready"]:
             mem_pts = agent_mem.get("points", 0)
             cache_pts = sem_cache.get("points", 0)
-            mode_label = MODE_LABELS.get(MEMORY_MODE, MEMORY_MODE)
             print(f"✅ Memory system ready — {mem_pts} memories, {cache_pts} cached responses")
-            print(f"   Mode: {mode_label}")
-            bc = report.get("blockchain", {})
-            if bc.get("status") == "ok":
-                print(f"   🔗 Aries: connected (v{bc.get('version')}, {bc.get('label')})")
-            elif MEMORY_MODE == "pro":
-                print(f"   ⚠️  Aries: not running (start: docker compose -f docker-compose.aries.yml up -d)")
-            ps = report.get("pulsar", {})
-            if ps.get("status") == "ok":
-                print(f"   📡 Pulsar: connected (real-time events)")
-            elif MEMORY_MODE in ("team", "pro"):
-                print(f"   ℹ️  Pulsar: not running (optional: docker compose -f docker-compose.pulsar.yml up -d)")
-            bm25 = report.get("bm25_sync", {})
-            if bm25.get("status") == "synced":
-                print(f"   🔍 BM25: synced from Qdrant ({bm25.get('indexed', 0)} indexed, {bm25.get('total', 0)} total)")
             if identity.get("agent_id"):
                 print(f"   Agent ID: {identity['agent_id'][:16]}...")
         else:

package/templates/base/execution/session_init.py

@@ -58,20 +58,6 @@ from init_collection import create_collection, create_payload_index
 QDRANT_URL = os.environ.get("QDRANT_URL", "http://localhost:6333")
 COLLECTIONS = ["agent_memory", "semantic_cache"]
 
-# Auth collection uses minimal 4-dimensional vectors (auth records don't need embeddings)
-AUTH_COLLECTION = "agent_auth"
-AUTH_VECTOR_DIM = 4
-AUTH_INDEXES = [
-    ("record_type", "keyword"),
-    ("entity_id", "keyword"),
-    ("entity_type", "keyword"),
-    ("project", "keyword"),
-    ("permissions", "keyword"),
-    ("action", "keyword"),
-    ("content_hash", "keyword"),
-    ("timestamp", "datetime"),
-]
-
 
 def check_qdrant() -> dict:
     """Check if Qdrant is running and accessible."""
@@ -213,31 +199,6 @@ def init_collections(force: bool = False) -> list:
     return results
 
 
-def init_auth_collection(force: bool = False) -> dict:
-    """Initialize the agent_auth collection for distributed auth."""
-    try:
-        req = Request(f"{QDRANT_URL}/collections/{AUTH_COLLECTION}", method="GET")
-        with urlopen(req, timeout=10) as response:
-            if not force:
-                return {"collection": AUTH_COLLECTION, "status": "exists"}
-            # Force recreate
-            del_req = Request(f"{QDRANT_URL}/collections/{AUTH_COLLECTION}", method="DELETE")
-            urlopen(del_req, timeout=10)
-    except HTTPError as e:
-        if e.code != 404:
-            return {"collection": AUTH_COLLECTION, "status": "error", "message": str(e)}
-    except URLError:
-        return {"collection": AUTH_COLLECTION, "status": "error", "message": "Cannot connect to Qdrant"}
-
-    try:
-        create_collection(QDRANT_URL, AUTH_COLLECTION, AUTH_VECTOR_DIM, "cosine")
-        for field, field_type in AUTH_INDEXES:
-            create_payload_index(QDRANT_URL, AUTH_COLLECTION, field, field_type)
-        return {"collection": AUTH_COLLECTION, "status": "created", "indexes": len(AUTH_INDEXES)}
-    except Exception as e:
-        return {"collection": AUTH_COLLECTION, "status": "error", "message": str(e)}
-
-
 def main():
     parser = argparse.ArgumentParser(
         description="Initialize AI agent session (Qdrant + Ollama check + collection setup)"
@@ -311,11 +272,6 @@ def main():
                 f"Initializing collections (dimension={get_embedding_dimension()})..."
             )
         collection_results = init_collections(force=args.force)
-
-        # Init auth collection (team/pro modes)
-        auth_result = init_auth_collection(force=args.force)
-        collection_results.append(auth_result)
-
         report["collections"] = collection_results
 
         for cr in collection_results:
@@ -323,11 +279,11 @@ def main():
                 status = cr["status"]
                 name = cr["collection"]
                 if status == "created":
-                    dim_info = f" ({cr['dimension']}d," if 'dimension' in cr else " ("
-                    print(f"  CREATED: {name}{dim_info} {cr.get('indexes', 0)} indexes)")
+                    print(
+                        f"  CREATED: {name} ({cr['dimension']}d, {cr['indexes']} indexes)"
+                    )
                 elif status == "exists":
-                    dim_info = f" ({cr['dimension']}d)" if 'dimension' in cr else ""
-                    print(f"  EXISTS: {name}{dim_info}")
+                    print(f"  EXISTS: {name} ({cr['dimension']}d)")
                 elif status == "dimension_mismatch":
                     print(
                         f"  MISMATCH: {name} (current={cr['current']}d, expected={cr['expected']}d)"

package/templates/base/skill-creator/scripts/init_skill.py

@@ -15,6 +15,9 @@ import subprocess
 import sys
 from pathlib import Path
 
+# Path to the templates directory (sibling of scripts/)
+_TEMPLATES_DIR = Path(__file__).resolve().parent.parent / "templates"
+
 
 SKILL_TEMPLATE = """---
 name: {skill_name}
@@ -261,12 +264,35 @@ def init_skill(skill_name, path):
         print(f"❌ Error creating resource directories: {e}")
         return None
 
+    # Create optional MCP server files (additive — skipped if templates missing)
+    mcp_template = _TEMPLATES_DIR / "mcp_server_template.py"
+    mcp_tools_template = _TEMPLATES_DIR / "mcp_tools_template.json"
+
+    if mcp_template.exists():
+        try:
+            mcp_server_content = mcp_template.read_text().replace("__SKILL_NAME__", skill_name)
+            mcp_server_path = skill_dir / "mcp_server.py"
+            mcp_server_path.write_text(mcp_server_content)
+            mcp_server_path.chmod(0o755)
+            print("✅ Created mcp_server.py")
+        except Exception as e:
+            print(f"  ⚠️  Could not create mcp_server.py: {e}")
+
+    if mcp_tools_template.exists():
+        try:
+            mcp_tools_path = skill_dir / "mcp_tools.json"
+            mcp_tools_path.write_text(mcp_tools_template.read_text())
+            print("✅ Created mcp_tools.json")
+        except Exception as e:
+            print(f"  ⚠️  Could not create mcp_tools.json: {e}")
+
     # Print next steps
     print(f"\n✅ Skill '{skill_name}' initialized successfully at {skill_dir}")
     print("\nNext steps:")
     print("1. Edit SKILL.md to complete the TODO items and update the description")
     print("2. Customize or delete the example files in scripts/, references/, and assets/")
-    print("3. Run the validator when ready to check the skill structure")
+    print("3. Fill in mcp_server.py + mcp_tools.json to expose tools via MCP (optional)")
+    print("4. Run the validator when ready to check the skill structure")
 
     return skill_dir
 

package/templates/base/skill-creator/scripts/update_catalog.py

@@ -98,6 +98,7 @@ def scan_skills(skills_dir: Path) -> list:
             'scripts': [],
             'references': [],
             'has_assets': False,
+            'has_mcp': (item / 'mcp_server.py').exists(),
             'parent': None,
         }
         
@@ -155,7 +156,10 @@ def generate_skill_entry(skill: dict) -> str:
     lines.append("| -------- | ----- |")
     lines.append(f"| **Name** | `{skill['name']}` |")
     lines.append(f"| **Location** | `{skill['location']}` |")
-    
+
+    if skill.get('has_mcp'):
+        lines.append("| **MCP Server** | `mcp_server.py` |")
+
     if skill['parent']:
         parent_title = skill['parent'].replace('-', ' ').title()
         parent_anchor = skill['parent'].replace('-', '')