@techwavedev/agi-agent-kit 1.6.0 → 1.6.1

package/templates/base/execution/memory_manager.py

@@ -58,7 +58,26 @@ 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
+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
 
 # Import BM25 index (optional — graceful if unavailable)
 try:
@@ -70,10 +89,20 @@ 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": []}
+    result = {"qdrant": "unknown", "embeddings": "unknown", "collections": [], "memory_mode": MEMORY_MODE}
 
     # Check Qdrant
     try:
@@ -121,6 +150,23 @@ 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
 
 
@@ -129,7 +175,9 @@ def auto_query(
     project: str = None, 
     threshold: float = 0.92,
     vector_weight: float = None,
-    text_weight: float = None
+    text_weight: float = None,
+    developer: str = None,
+    shared_only: bool = False
 ) -> dict:
     """
     Smart query: check cache first, then retrieve context using Hybrid Search.
@@ -145,7 +193,8 @@ def auto_query(
         "cache_hit": False,
         "context_chunks": [],
         "tokens_saved_estimate": 0,
-        "search_type": "hybrid"
+        "search_type": "hybrid",
+        "developer_id": developer or resolve_developer_id()
     }
 
     # Step 1: Semantic cache check
@@ -163,9 +212,22 @@ def auto_query(
 
     # Step 2: Context retrieval
     try:
-        filters = None
+        # Build identity-aware filter
+        filter_conditions = []
         if project:
-            filters = {"must": [{"key": "project", "match": {"value": 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
 
         context = retrieve_context(
             query, 
@@ -216,6 +278,8 @@ 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(
@@ -230,6 +294,11 @@ 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(
@@ -246,6 +315,11 @@ 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(
@@ -260,6 +334,8 @@ 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
@@ -285,7 +361,9 @@ Examples:
                 args.project, 
                 args.threshold,
                 vector_weight=args.vector_weight,
-                text_weight=args.text_weight
+                text_weight=args.text_weight,
+                developer=args.developer,
+                shared_only=getattr(args, "shared_only", False)
             )
             print(json.dumps(result, indent=2))
             sys.exit(0 if result["source"] != "none" else 1)
@@ -296,13 +374,64 @@ Examples:
                 metadata["project"] = args.project
             if args.tags:
                 metadata["tags"] = args.tags
-            result = store_memory(args.content, args.type, metadata)
+            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"}
+
             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
+                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)
             )
             result = retrieve_context(
                 args.query,
@@ -325,7 +454,10 @@ Examples:
 
         elif args.command == "list":
             filters = build_filter(
-                type_filter=getattr(args, "type", None), project=args.project
+                type_filter=getattr(args, "type", None),
+                project=args.project,
+                developer=getattr(args, "developer", None),
+                shared_only=getattr(args, "shared_only", False)
             )
             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-6)
-    --all       Run all 6 scenarios
+    --scenario  Scenario number to run (1-10)
+    --all       Run all 10 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"]:
+    for script in ["dispatch_agent_team.py", "agent_team_result.py", "test_qdrant_handoff.py"]:
         path = root / "execution" / script
         checks[f"script:{script}"] = path.exists()
 
@@ -412,6 +412,102 @@ 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,
@@ -419,13 +515,17 @@ 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, 7), help="Scenario number (1-6)")
-    parser.add_argument("--all", action="store_true", help="Run all 6 scenarios")
+    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("--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()
@@ -438,7 +538,10 @@ def main():
 
     # Validate setup first
     setup = validate_setup(root)
-    if not setup["pass"]:
+    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):
         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,6 +36,8 @@ 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:
@@ -81,6 +83,41 @@ 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"
@@ -149,6 +186,7 @@ def main():
     report = {
         "qdrant": {},
         "ollama": {},
+        "blockchain": {},
         "memory_ready": False,
         "actions_taken": [],
         "issues": [],
@@ -207,6 +245,33 @@ 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
@@ -238,6 +303,8 @@ 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"),
@@ -249,7 +316,22 @@ 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,6 +58,20 @@ 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."""
@@ -199,6 +213,31 @@ 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)"
@@ -272,6 +311,11 @@ 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:
@@ -279,11 +323,11 @@ def main():
                 status = cr["status"]
                 name = cr["collection"]
                 if status == "created":
-                    print(
-                        f"  CREATED: {name} ({cr['dimension']}d, {cr['indexes']} indexes)"
-                    )
+                    dim_info = f" ({cr['dimension']}d," if 'dimension' in cr else " ("
+                    print(f"  CREATED: {name}{dim_info} {cr.get('indexes', 0)} indexes)")
                 elif status == "exists":
-                    print(f"  EXISTS: {name} ({cr['dimension']}d)")
+                    dim_info = f" ({cr['dimension']}d)" if 'dimension' in cr else ""
+                    print(f"  EXISTS: {name}{dim_info}")
                 elif status == "dimension_mismatch":
                     print(
                         f"  MISMATCH: {name} (current={cr['current']}d, expected={cr['expected']}d)"