omni-cortex 1.17.2__tar.gz → 1.17.6__tar.gz

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omni-cortex
-Version: 1.17.2
+Version: 1.17.6
 Summary: Give Claude Code a perfect memory - auto-logs everything, searches smartly, and gets smarter over time
 Project-URL: Homepage, https://github.com/AllCytes/Omni-Cortex
 Project-URL: Repository, https://github.com/AllCytes/Omni-Cortex
@@ -27,6 +27,11 @@ Requires-Dist: mcp>=1.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0.0
+Provides-Extra: dashboard
+Requires-Dist: fastapi>=0.115.0; extra == 'dashboard'
+Requires-Dist: uvicorn[standard]>=0.30.0; extra == 'dashboard'
+Requires-Dist: watchdog>=4.0.0; extra == 'dashboard'
+Requires-Dist: websockets>=12.0; extra == 'dashboard'
 Provides-Extra: dev
 Requires-Dist: black>=23.0.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/dashboard/backend/main.py

@@ -131,10 +131,10 @@ class SecurityHeadersMiddleware(BaseHTTPMiddleware):
         response.headers["Content-Security-Policy"] = (
             "default-src 'self'; "
             "script-src 'self' 'unsafe-inline' 'unsafe-eval'; "  # Vue needs these
-            "style-src 'self' 'unsafe-inline'; "  # Tailwind needs inline
+            "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; "  # Tailwind + Google Fonts
             "img-src 'self' data: blob: https:; "  # Allow AI-generated images
             "connect-src 'self' ws: wss: https://generativelanguage.googleapis.com; "
-            "font-src 'self'; "
+            "font-src 'self' https://fonts.gstatic.com; "  # Google Fonts
             "frame-ancestors 'none';"
         )
 

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/hooks/post_tool_use.py

@@ -148,6 +148,8 @@ def ensure_database(db_path: Path) -> sqlite3.Connection:
     """
     db_path.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(db_path))
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA busy_timeout = 5000")
 
     # Check if schema exists
     cursor = conn.cursor()

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/hooks/pre_tool_use.py

@@ -146,6 +146,8 @@ def ensure_database(db_path: Path) -> sqlite3.Connection:
     """
     db_path.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(db_path))
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA busy_timeout = 5000")
 
     # Check if schema exists
     cursor = conn.cursor()

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/hooks/stop.py

@@ -60,6 +60,8 @@ def main():
 
         # Connect to database
         conn = sqlite3.connect(str(db_path))
+        conn.execute("PRAGMA journal_mode = WAL")
+        conn.execute("PRAGMA busy_timeout = 5000")
         conn.row_factory = sqlite3.Row
         cursor = conn.cursor()
 

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/hooks/subagent_stop.py

@@ -69,6 +69,8 @@ def main():
 
         # Connect to database
         conn = sqlite3.connect(str(db_path))
+        conn.execute("PRAGMA journal_mode = WAL")
+        conn.execute("PRAGMA busy_timeout = 5000")
         cursor = conn.cursor()
 
         # Log the subagent completion as an activity

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/hooks/user_prompt.py

@@ -3,6 +3,8 @@
 
 This hook is called by Claude Code when the user submits a prompt.
 It logs the user message to the Cortex database for later style analysis.
+Messages are synced to both the project database and the global database
+to enable cross-project style analysis (Write Like Me skill).
 
 Hook configuration for settings.json:
 {
@@ -39,10 +41,110 @@ def get_db_path() -> Path:
     return Path(project_path) / ".omni-cortex" / "cortex.db"
 
 
+def get_global_db_path() -> Path:
+    """Get the global database path."""
+    # Check for custom location in environment
+    global_dir = os.environ.get("OMNI_CORTEX_GLOBAL_DIR")
+    if global_dir:
+        return Path(global_dir) / "cortex.db"
+
+    # Default to D:\Projects\.omni-cortex for this system
+    # Fallback to ~/.omni-cortex if that doesn't exist
+    windows_global = Path("D:/Projects/.omni-cortex")
+    if windows_global.exists():
+        return windows_global / "cortex.db"
+
+    return Path.home() / ".omni-cortex" / "cortex.db"
+
+
+def ensure_global_user_messages_table(conn: sqlite3.Connection) -> None:
+    """Ensure user_messages table exists in the global database."""
+    cursor = conn.cursor()
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='user_messages'"
+    )
+    if cursor.fetchone() is None:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS user_messages (
+                id TEXT PRIMARY KEY,
+                session_id TEXT,
+                timestamp TEXT NOT NULL,
+                content TEXT NOT NULL,
+                word_count INTEGER,
+                char_count INTEGER,
+                line_count INTEGER,
+                has_code_blocks INTEGER DEFAULT 0,
+                has_questions INTEGER DEFAULT 0,
+                has_commands INTEGER DEFAULT 0,
+                tone_indicators TEXT,
+                project_path TEXT,
+                metadata TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_global_user_messages_timestamp ON user_messages(timestamp DESC);
+            CREATE INDEX IF NOT EXISTS idx_global_user_messages_project ON user_messages(project_path);
+        """)
+        conn.commit()
+
+
+def sync_to_global(
+    message_id: str,
+    session_id: str,
+    timestamp: str,
+    content: str,
+    analysis: dict,
+    project_path: str,
+) -> bool:
+    """Sync user message to the global database for cross-project style analysis."""
+    try:
+        global_db_path = get_global_db_path()
+        global_db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        conn = sqlite3.connect(str(global_db_path))
+        conn.execute("PRAGMA journal_mode = WAL")
+        conn.execute("PRAGMA busy_timeout = 5000")
+        ensure_global_user_messages_table(conn)
+
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            INSERT INTO user_messages (
+                id, session_id, timestamp, content, word_count, char_count,
+                line_count, has_code_blocks, has_questions, has_commands,
+                tone_indicators, project_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                content = excluded.content,
+                tone_indicators = excluded.tone_indicators
+            """,
+            (
+                message_id,
+                session_id,
+                timestamp,
+                content,
+                analysis["word_count"],
+                analysis["char_count"],
+                analysis["line_count"],
+                analysis["has_code_blocks"],
+                analysis["has_questions"],
+                analysis["has_commands"],
+                analysis["tone_indicators"],
+                project_path,
+            ),
+        )
+        conn.commit()
+        conn.close()
+        return True
+    except Exception:
+        # Silently fail - global sync is best-effort
+        return False
+
+
 def ensure_database(db_path: Path) -> sqlite3.Connection:
     """Ensure database exists and has user_messages table."""
     db_path.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(db_path))
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA busy_timeout = 5000")
 
     # Check if user_messages table exists
     cursor = conn.cursor()
@@ -177,7 +279,10 @@ def main():
         # Generate message ID
         message_id = generate_id()
 
-        # Insert message record
+        # Generate timestamp
+        timestamp = datetime.now(timezone.utc).isoformat()
+
+        # Insert message record into project database
         cursor = conn.cursor()
         cursor.execute(
             """
@@ -190,7 +295,7 @@ def main():
             (
                 message_id,
                 session_id,
-                datetime.now(timezone.utc).isoformat(),
+                timestamp,
                 prompt,
                 analysis["word_count"],
                 analysis["char_count"],
@@ -205,6 +310,16 @@ def main():
         conn.commit()
         conn.close()
 
+        # Sync to global database for cross-project style analysis
+        sync_to_global(
+            message_id=message_id,
+            session_id=session_id,
+            timestamp=timestamp,
+            content=prompt,
+            analysis=analysis,
+            project_path=project_path,
+        )
+
         # Return empty response (don't modify prompt)
         print(json.dumps({}))
 

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/omni_cortex/__init__.py

@@ -1,3 +1,3 @@
 """Omni Cortex MCP - Universal Memory System for Claude Code."""
 
-__version__ = "1.17.1"
+__version__ = "1.17.6"

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/omni_cortex/dashboard.py

@@ -61,12 +61,18 @@ def find_dashboard_dir() -> Path | None:
     """Find the dashboard directory.
 
     Searches in order:
-    1. Development directory (cloned repo)
-    2. Package shared-data (installed via pip)
-    3. Site-packages share location
+    1. Bundled inside package (works for user and system installs)
+    2. Development directory (cloned repo)
+    3. Package shared-data (installed via pip system-wide)
+    4. Site-packages share location
     """
     package_dir = Path(__file__).parent
 
+    # Check for bundled dashboard inside package (most reliable for pip installs)
+    bundled_dashboard = package_dir / "_bundled" / "dashboard"
+    if bundled_dashboard.exists() and (bundled_dashboard / "backend" / "main.py").exists():
+        return bundled_dashboard
+
     # Check for development directory (repo structure)
     # Go up from src/omni_cortex to repo root, then dashboard
     repo_root = package_dir.parent.parent
@@ -74,7 +80,7 @@ def find_dashboard_dir() -> Path | None:
     if dashboard_in_repo.exists() and (dashboard_in_repo / "backend" / "main.py").exists():
         return dashboard_in_repo
 
-    # Check pip shared-data location
+    # Check pip shared-data location (for backwards compatibility)
     # On Unix: ~/.local/share/omni-cortex/dashboard
     # On Windows: %APPDATA%/Python/share/omni-cortex/dashboard
     import site

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/omni_cortex/database/connection.py

@@ -23,6 +23,7 @@ def _configure_connection(conn: sqlite3.Connection) -> None:
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA foreign_keys = ON")
     conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA busy_timeout = 5000")
     conn.execute("PRAGMA synchronous = NORMAL")
     conn.execute("PRAGMA cache_size = -64000")  # 64MB cache
 

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/omni_cortex/database/sync.py

@@ -1,7 +1,8 @@
 """Global index synchronization for cross-project memory search.
 
-This module handles syncing memories from project-local databases to the
-global database at ~/.omni-cortex/global.db, enabling cross-project search.
+This module handles syncing memories and user messages from project-local
+databases to the global database at ~/.omni-cortex/global.db, enabling
+cross-project search and style analysis.
 """
 
 import json
@@ -17,6 +18,260 @@ from ..utils.timestamps import now_iso
 logger = logging.getLogger(__name__)
 
 
+# SQL to create user_messages table in global database
+USER_MESSAGES_SCHEMA = """
+CREATE TABLE IF NOT EXISTS user_messages (
+    id TEXT PRIMARY KEY,
+    session_id TEXT,
+    timestamp TEXT NOT NULL,
+    content TEXT NOT NULL,
+    word_count INTEGER,
+    char_count INTEGER,
+    line_count INTEGER,
+    has_code_blocks INTEGER DEFAULT 0,
+    has_questions INTEGER DEFAULT 0,
+    has_commands INTEGER DEFAULT 0,
+    tone_indicators TEXT,
+    project_path TEXT,
+    metadata TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_global_user_messages_timestamp ON user_messages(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_global_user_messages_project ON user_messages(project_path);
+"""
+
+
+def ensure_user_messages_table(conn: sqlite3.Connection) -> None:
+    """Ensure user_messages table exists in the database."""
+    cursor = conn.cursor()
+    cursor.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='user_messages'"
+    )
+    if cursor.fetchone() is None:
+        # Table doesn't exist, create it
+        for statement in USER_MESSAGES_SCHEMA.strip().split(';'):
+            statement = statement.strip()
+            if statement:
+                try:
+                    conn.execute(statement)
+                except sqlite3.OperationalError as e:
+                    if "already exists" not in str(e).lower():
+                        raise
+        conn.commit()
+        logger.info("Created user_messages table in global database")
+
+
+def sync_user_message_to_global(
+    message_id: str,
+    session_id: Optional[str],
+    timestamp: str,
+    content: str,
+    word_count: int,
+    char_count: int,
+    line_count: int,
+    has_code_blocks: int,
+    has_questions: int,
+    has_commands: int,
+    tone_indicators: str,
+    project_path: str,
+) -> bool:
+    """Sync a user message to the global database.
+
+    This enables cross-project style analysis for the Write Like Me skill.
+
+    Args:
+        message_id: Unique message ID
+        session_id: Associated session ID
+        timestamp: ISO 8601 timestamp
+        content: Message content
+        word_count: Word count
+        char_count: Character count
+        line_count: Line count
+        has_code_blocks: Whether message has code blocks (0/1)
+        has_questions: Whether message has questions (0/1)
+        has_commands: Whether message starts with slash command (0/1)
+        tone_indicators: JSON array of tone indicators
+        project_path: Source project path
+
+    Returns:
+        True if synced successfully
+    """
+    config = load_config()
+    if not config.global_sync_enabled:
+        return False
+
+    try:
+        global_conn = init_database(is_global=True)
+
+        # Ensure user_messages table exists
+        ensure_user_messages_table(global_conn)
+
+        cursor = global_conn.cursor()
+
+        # Upsert the message
+        cursor.execute(
+            """
+            INSERT INTO user_messages (
+                id, session_id, timestamp, content, word_count, char_count,
+                line_count, has_code_blocks, has_questions, has_commands,
+                tone_indicators, project_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                content = excluded.content,
+                tone_indicators = excluded.tone_indicators
+            """,
+            (
+                message_id,
+                session_id,
+                timestamp,
+                content,
+                word_count,
+                char_count,
+                line_count,
+                has_code_blocks,
+                has_questions,
+                has_commands,
+                tone_indicators,
+                project_path,
+            ),
+        )
+
+        global_conn.commit()
+        logger.debug(f"Synced user message {message_id} to global index")
+        return True
+
+    except Exception as e:
+        logger.warning(f"Failed to sync user message {message_id} to global: {e}")
+        return False
+
+
+def get_global_user_messages(
+    limit: int = 100,
+    project_filter: Optional[str] = None,
+    exclude_commands: bool = True,
+    exclude_short: bool = True,
+    min_length: int = 30,
+) -> list[dict]:
+    """Get user messages from the global database for style analysis.
+
+    Args:
+        limit: Maximum messages to return
+        project_filter: Filter by project path (substring match)
+        exclude_commands: Exclude messages starting with /
+        exclude_short: Exclude very short messages
+        min_length: Minimum content length when exclude_short=True
+
+    Returns:
+        List of message dicts suitable for style analysis
+    """
+    try:
+        global_conn = init_database(is_global=True)
+
+        # Ensure table exists
+        ensure_user_messages_table(global_conn)
+
+        cursor = global_conn.cursor()
+
+        where_conditions = ["1=1"]
+        params: list = []
+
+        if exclude_commands:
+            where_conditions.append("has_commands = 0")
+
+        if exclude_short:
+            where_conditions.append("char_count >= ?")
+            params.append(min_length)
+
+        if project_filter:
+            where_conditions.append("project_path LIKE ?")
+            params.append(f"%{project_filter}%")
+
+        params.append(limit)
+
+        cursor.execute(
+            f"""
+            SELECT * FROM user_messages
+            WHERE {' AND '.join(where_conditions)}
+            ORDER BY timestamp DESC
+            LIMIT ?
+            """,
+            params,
+        )
+
+        results = []
+        for row in cursor.fetchall():
+            results.append({
+                "id": row["id"],
+                "content": row["content"],
+                "word_count": row["word_count"],
+                "char_count": row["char_count"],
+                "has_questions": bool(row["has_questions"]),
+                "has_code_blocks": bool(row["has_code_blocks"]),
+                "tone_indicators": row["tone_indicators"],
+                "project_path": row["project_path"],
+                "timestamp": row["timestamp"],
+            })
+
+        return results
+
+    except Exception as e:
+        logger.error(f"Failed to get global user messages: {e}")
+        return []
+
+
+def sync_all_project_user_messages() -> int:
+    """Sync all user messages from current project to global index.
+
+    Returns:
+        Number of messages synced
+    """
+    config = load_config()
+    if not config.global_sync_enabled:
+        return 0
+
+    try:
+        project_conn = init_database()
+        project_path = str(get_project_path())
+
+        cursor = project_conn.cursor()
+
+        # Check if user_messages table exists in project
+        cursor.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='user_messages'"
+        )
+        if cursor.fetchone() is None:
+            logger.debug("No user_messages table in project database")
+            return 0
+
+        cursor.execute("SELECT * FROM user_messages")
+
+        count = 0
+        for row in cursor.fetchall():
+            synced = sync_user_message_to_global(
+                message_id=row["id"],
+                session_id=row["session_id"],
+                timestamp=row["timestamp"],
+                content=row["content"],
+                word_count=row["word_count"] or 0,
+                char_count=row["char_count"] or 0,
+                line_count=row["line_count"] or 0,
+                has_code_blocks=row["has_code_blocks"] or 0,
+                has_questions=row["has_questions"] or 0,
+                has_commands=row["has_commands"] or 0,
+                tone_indicators=row["tone_indicators"] or "[]",
+                project_path=project_path,
+            )
+            if synced:
+                count += 1
+
+        logger.info(f"Synced {count} user messages to global index")
+        return count
+
+    except Exception as e:
+        logger.error(f"Failed to sync project user messages: {e}")
+        return 0
+
+
 def sync_memory_to_global(
     memory_id: str,
     content: str,

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/omni_cortex/setup.py

@@ -56,21 +56,27 @@ def get_hooks_dir() -> Path:
     """Get the hooks directory.
 
     Checks multiple locations for hooks:
-    1. Development: <project>/hooks/
-    2. Installed: <site-packages>/../share/omni-cortex/hooks/
-    3. Installed: <prefix>/share/omni-cortex/hooks/
+    1. Bundled inside package (works for user and system installs)
+    2. Development: <project>/hooks/
+    3. Installed: <site-packages>/../share/omni-cortex/hooks/
+    4. Installed: <prefix>/share/omni-cortex/hooks/
     """
+    # Try relative to package first (bundled location)
+    import omni_cortex
+    pkg_path = Path(omni_cortex.__file__).parent
+
+    # Check bundled location inside package (most reliable for pip installs)
+    bundled_hooks = pkg_path / "_bundled" / "hooks"
+    if bundled_hooks.exists():
+        return bundled_hooks
+
     # Try development location
     package_dir = get_package_dir()
     hooks_dir = package_dir / "hooks"
     if hooks_dir.exists():
         return hooks_dir
 
-    # Try relative to package
-    import omni_cortex
-    pkg_path = Path(omni_cortex.__file__).parent
-
-    # Check various installed locations
+    # Check various installed locations (shared-data, for backwards compatibility)
     candidates = [
         pkg_path.parent.parent / "hooks",
         pkg_path.parent.parent / "share" / "omni-cortex" / "hooks",
@@ -102,11 +108,19 @@ def setup_mcp_server() -> bool:
         config["mcpServers"] = {}
 
     # Add omni-cortex server
-    config["mcpServers"]["omni-cortex"] = {
+    server_config = {
         "command": sys.executable,
         "args": ["-m", "omni_cortex.server"],
     }
 
+    # For editable installs, add PYTHONPATH so the MCP server can find the source
+    src_dir = Path(__file__).parent.parent
+    repo_root = src_dir.parent
+    if (repo_root / "pyproject.toml").exists() and (repo_root / ".git").exists():
+        server_config["env"] = {"PYTHONPATH": str(src_dir)}
+
+    config["mcpServers"]["omni-cortex"] = server_config
+
     # Write config
     config_path.parent.mkdir(parents=True, exist_ok=True)
     with open(config_path, "w") as f:

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "omni-cortex"
-version = "1.17.2"
+version = "1.17.6"
 description = "Give Claude Code a perfect memory - auto-logs everything, searches smartly, and gets smarter over time"
 readme = "README.md"
 license = "MIT"
@@ -46,6 +46,12 @@ semantic = [
     "sentence-transformers>=2.2.0",
     "numpy>=1.24.0",
 ]
+dashboard = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.30.0",
+    "websockets>=12.0",
+    "watchdog>=4.0.0",
+]
 dev = [
     "pytest>=7.0.0",
     "pytest-asyncio>=0.21.0",
@@ -60,10 +66,18 @@ omni-cortex-dashboard = "omni_cortex.dashboard:main"
 
 [tool.hatch.build]
 sources = ["src"]
+dev-mode-dirs = ["src"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["omni_cortex"]
 
+# Include dashboard and hooks inside the package (not as shared-data)
+# This ensures they work for both user and system installs
+[tool.hatch.build.targets.wheel.force-include]
+"hooks" = "omni_cortex/_bundled/hooks"
+"dashboard/backend" = "omni_cortex/_bundled/dashboard/backend"
+"dashboard/frontend/dist" = "omni_cortex/_bundled/dashboard/frontend/dist"
+
 [tool.hatch.build.targets.sdist]
 include = [
     "/src",
@@ -74,10 +88,10 @@ include = [
     "/README.md",
 ]
 
+# Keep shared-data for backwards compatibility with system installs
 [tool.hatch.build.targets.wheel.shared-data]
 "hooks" = "share/omni-cortex/hooks"
 "dashboard/backend" = "share/omni-cortex/dashboard/backend"
-"dashboard/frontend/dist" = "share/omni-cortex/dashboard/frontend/dist"
 
 [tool.ruff]
 line-length = 100

{omni_cortex-1.17.2 → omni_cortex-1.17.6}/scripts/update_docs_pdfs.py

@@ -181,7 +181,7 @@ def create_callout_box(text, styles, color=PRIMARY):
 def create_dashboard_guide():
     """Create the updated Dashboard Guide PDF"""
     styles = get_styles()
-    filename = os.path.join(OUTPUT_DIR, 'OmniCortex_DashboardGuide.pdf')
+    filename = os.path.join(OUTPUT_DIR, '04_OmniCortex_DashboardGuide.pdf')
 
     doc = SimpleDocTemplate(
         filename,
@@ -527,7 +527,7 @@ def create_dashboard_guide():
 def create_feature_comparison():
     """Create the updated Feature Comparison PDF"""
     styles = get_styles()
-    filename = os.path.join(OUTPUT_DIR, 'OmniCortex_FeatureComparison.pdf')
+    filename = os.path.join(OUTPUT_DIR, '05_OmniCortex_FeatureComparison.pdf')
 
     doc = SimpleDocTemplate(
         filename,
@@ -690,7 +690,7 @@ def create_feature_comparison():
 def create_storage_architecture():
     """Create the updated Storage Architecture PDF"""
     styles = get_styles()
-    filename = os.path.join(OUTPUT_DIR, 'OmniCortex_StorageArchitecture.pdf')
+    filename = os.path.join(OUTPUT_DIR, '06_OmniCortex_StorageArchitecture.pdf')
 
     doc = SimpleDocTemplate(
         filename,
@@ -921,7 +921,7 @@ def create_storage_architecture():
 def create_quick_start():
     """Create the updated Quick Start PDF"""
     styles = get_styles()
-    filename = os.path.join(OUTPUT_DIR, 'OmniCortex_QuickStart.pdf')
+    filename = os.path.join(OUTPUT_DIR, '02_OmniCortex_QuickStart.pdf')
 
     doc = SimpleDocTemplate(
         filename,
@@ -942,50 +942,69 @@ def create_quick_start():
         styles['OmniBody']
     ))
 
-    # 1. Installation
-    elements.append(Paragraph("1. Installation", styles['SectionHeader']))
+    # Installation - 3 Simple Commands
+    elements.append(Paragraph("3 Commands to Get Started", styles['SectionHeader']))
+    elements.append(Paragraph(
+        "OmniCortex uses an automatic setup process - no manual configuration required!",
+        styles['OmniBody']
+    ))
+    elements.append(Spacer(1, 8))
+
+    # Step 1
+    elements.append(Paragraph("<b>Step 1: Install the Package</b>", styles['OmniBody']))
     elements.append(create_callout_box("pip install omni-cortex", styles, ACCENT))
     elements.append(Spacer(1, 8))
-    elements.append(Paragraph("Or with optional features:", styles['OmniBody']))
-    elements.append(create_callout_box(
-        "pip install omni-cortex[semantic]  # Semantic search<br/>"
-        "pip install omni-cortex[all]       # All features",
-        styles, SECONDARY
+
+    # Step 2
+    elements.append(Paragraph("<b>Step 2: Run Automatic Setup</b>", styles['OmniBody']))
+    elements.append(create_callout_box("omni-cortex-setup", styles, ACCENT))
+    elements.append(Paragraph(
+        "This automatically configures the MCP server and hooks in Claude Code. "
+        "No manual JSON editing required!",
+        styles['OmniBody']
     ))
+    elements.append(Spacer(1, 8))
 
-    # 2. Configure
-    elements.append(Paragraph("2. Configure Claude Code", styles['SectionHeader']))
+    # Step 3
+    elements.append(Paragraph("<b>Step 3: Launch Dashboard (Optional)</b>", styles['OmniBody']))
+    elements.append(create_callout_box("omni-cortex-dashboard", styles, ACCENT))
     elements.append(Paragraph(
-        "Add OmniCortex to your Claude Code MCP configuration:",
+        "Opens the web dashboard at http://localhost:8765",
         styles['OmniBody']
     ))
-    elements.append(Paragraph("~/.claude/claude_desktop_config.json:", styles['OmniBody']))
-
-    config_text = '''{
-  "mcpServers": {
-    "omni-cortex": {
-      "command": "omni-cortex",
-      "args": ["serve"]
-    }
-  }
-}'''
-    elements.append(Paragraph(f"<pre>{config_text}</pre>", styles['CodeBlock']))
-
-    # 3. First Use
-    elements.append(Paragraph("3. First Use", styles['SectionHeader']))
+    elements.append(Spacer(1, 12))
+
+    # Restart reminder
+    elements.append(create_callout_box(
+        "Important: Restart Claude Code after running omni-cortex-setup",
+        styles, colors.HexColor('#E74C3C')
+    ))
+    elements.append(Spacer(1, 12))
+
+    # Optional features
+    elements.append(Paragraph("Optional: Enhanced Features", styles['SubHeader']))
+    elements.append(create_callout_box(
+        "pip install omni-cortex[semantic]   # AI-powered semantic search<br/>"
+        "pip install omni-cortex[dashboard]  # Dashboard dependencies",
+        styles, SECONDARY
+    ))
+
+    # What happens automatically
+    elements.append(Paragraph("What Happens Automatically", styles['SectionHeader']))
     elements.append(Paragraph(
-        "Start Claude Code in any project directory. OmniCortex will automatically:",
+        "After setup, when you start Claude Code in any project directory:",
         styles['OmniBody']
     ))
     for item in [
-        "Create .omni-cortex/ directory in your project",
-        "Initialize cortex.db SQLite database",
-        "Make memory tools available to Claude",
+        "Creates .omni-cortex/ directory in your project",
+        "Initializes cortex.db SQLite database",
+        "Makes 18 memory tools available to Claude",
+        "Starts logging all tool activity automatically",
     ]:
         elements.append(Paragraph(f"• {item}", styles['BulletItem']))
 
-    # 4. Core Tools
-    elements.append(Paragraph("4. Core Tools", styles['SectionHeader']))
+    # Core Tools
+    elements.append(Paragraph("Core Tools", styles['SectionHeader']))
     tools_data = [
         ['Tool', 'Purpose', 'Example'],
         ['cortex_remember', 'Store information', 'Store this API pattern'],
@@ -993,24 +1012,14 @@ def create_quick_start():
         ['cortex_list_memories', 'Browse all', 'Show recent decisions'],
         ['cortex_update_memory', 'Modify memory', 'Add tags to memory'],
         ['cortex_link_memories', 'Create relations', 'Link related solutions'],
+        ['cortex_start_session', 'Begin work session', 'Get previous context'],
     ]
     elements.append(create_table(tools_data, [1.5*inch, 1.3*inch, 2.2*inch]))
 
-    # 5. Web Dashboard
-    elements.append(Paragraph("5. Web Dashboard", styles['SectionHeader']))
-    elements.append(create_callout_box("omni-cortex-dashboard", styles, ACCENT))
-    elements.append(Spacer(1, 8))
-    elements.append(Paragraph(
-        "Opens a visual interface at http://localhost:8765 for browsing memories, viewing activity logs, "
-        "and analyzing your knowledge base. Includes <b>Response Composer</b> for generating style-matched "
-        "responses to community messages.",
-        styles['OmniBody']
-    ))
-
     elements.append(PageBreak())
 
-    # 6. Storage Locations
-    elements.append(Paragraph("6. Storage Locations", styles['SectionHeader']))
+    # Storage Locations
+    elements.append(Paragraph("Storage Locations", styles['SectionHeader']))
     storage_data = [
         ['Location', 'Path', 'Purpose'],
         ['Project DB', '.omni-cortex/cortex.db', 'Project memories & activities'],
@@ -1019,8 +1028,8 @@ def create_quick_start():
     ]
     elements.append(create_table(storage_data, [1.2*inch, 2.2*inch, 2.1*inch]))
 
-    # 7. Memory Types
-    elements.append(Paragraph("7. Memory Types", styles['SectionHeader']))
+    # Memory Types
+    elements.append(Paragraph("Memory Types", styles['SectionHeader']))
     types_data = [
         ['Type', 'Use For'],
         ['fact', 'Technical facts, API details, configurations'],
@@ -1032,8 +1041,8 @@ def create_quick_start():
     ]
     elements.append(create_table(types_data, [1.5*inch, 4*inch]))
 
-    # 8. Pro Tips
-    elements.append(Paragraph("8. Pro Tips", styles['SectionHeader']))
+    # Pro Tips
+    elements.append(Paragraph("Pro Tips", styles['SectionHeader']))
     for item in [
         'Ask Claude to "remember this" when you solve a tricky problem',
         "Use tags liberally - they're searchable and filterable",
@@ -1076,7 +1085,7 @@ def create_quick_start():
 def create_troubleshooting_faq():
     """Create the updated Troubleshooting FAQ PDF"""
     styles = get_styles()
-    filename = os.path.join(OUTPUT_DIR, 'OmniCortex_TroubleshootingFAQ.pdf')
+    filename = os.path.join(OUTPUT_DIR, '07_OmniCortex_TroubleshootingFAQ.pdf')
 
     doc = SimpleDocTemplate(
         filename,