claude-jacked 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

jacked/cli.py

@@ -32,11 +32,18 @@ def setup_logging(verbose: bool = False):
     )
 
 
-def get_config() -> SmartForkConfig:
-    """Load configuration from environment."""
+def get_config(quiet: bool = False) -> Optional[SmartForkConfig]:
+    """Load configuration from environment.
+
+    Args:
+        quiet: If True, return None instead of printing error and exiting.
+               Used by hooks that should fail gracefully.
+    """
     try:
         return SmartForkConfig.from_env()
     except ValueError as e:
+        if quiet:
+            return None
         console.print(f"[red]Configuration error:[/red] {e}")
         console.print("\nSet these environment variables:")
         console.print("  QDRANT_CLAUDE_SESSIONS_ENDPOINT=<your-qdrant-url>")
@@ -63,7 +70,12 @@ def index(session: Optional[str], repo: Optional[str]):
     import os
     from jacked.indexer import SessionIndexer
 
-    config = get_config()
+    # Try to get config quietly - if not configured, nudge and exit cleanly
+    config = get_config(quiet=True)
+    if config is None:
+        print("[jacked] Indexing skipped - run 'jacked configure' to set up Qdrant")
+        sys.exit(0)
+
     indexer = SessionIndexer(config)
 
     if session:
@@ -623,6 +635,8 @@ def _get_sound_command(hook_type: str) -> str:
 
 def _install_sound_hooks(existing: dict, settings_path: Path):
     """Install sound notification hooks."""
+    import json
+
     marker = _sound_hook_marker()
 
     # Notification hook
@@ -680,9 +694,280 @@ def _remove_sound_hooks(settings_path: Path) -> bool:
     return modified
 
 
+def _get_behavioral_rules() -> str:
+    """Load behavioral rules from data file."""
+    rules_path = _get_data_root() / "rules" / "jacked_behaviors.md"
+    if not rules_path.exists():
+        raise FileNotFoundError(f"Behavioral rules not found: {rules_path}")
+    return rules_path.read_text(encoding="utf-8").strip()
+
+
+def _behavioral_rules_marker() -> str:
+    """Start marker for jacked behavioral rules block."""
+    return "# jacked-behaviors-v2"
+
+
+def _behavioral_rules_end_marker() -> str:
+    """End marker for jacked behavioral rules block."""
+    return "# end-jacked-behaviors"
+
+
+def _install_behavioral_rules(claude_md_path: Path):
+    """Install behavioral rules into CLAUDE.md with marker boundaries.
+
+    - Show rules before writing, require confirmation
+    - Backup file before first modification
+    - Atomic write (build in memory, write once)
+    - Skip if already installed with same version
+    """
+    import shutil
+
+    try:
+        rules_text = _get_behavioral_rules()
+    except FileNotFoundError as e:
+        console.print(f"[red][FAIL][/red] {e}")
+        console.print("[yellow]Skipping behavioral rules installation[/yellow]")
+        return
+
+    start_marker = _behavioral_rules_marker()
+    end_marker = _behavioral_rules_end_marker()
+
+    # Read existing content
+    existing_content = ""
+    if claude_md_path.exists():
+        existing_content = claude_md_path.read_text(encoding="utf-8")
+
+    # Check if already installed (any version)
+    marker_prefix = "# jacked-behaviors-v"
+    has_start = marker_prefix in existing_content
+    has_end = end_marker in existing_content
+
+    # Orphaned marker detection: start without end (or end without start)
+    if has_start != has_end:
+        which = "start" if has_start else "end"
+        missing = "end" if has_start else "start"
+        console.print(f"[red][FAIL][/red] Found {which} marker but no {missing} marker in CLAUDE.md")
+        console.print("Your CLAUDE.md has a corrupted jacked rules block. Please fix it manually:")
+        console.print(f"  Start marker: {start_marker}")
+        console.print(f"  End marker: {end_marker}")
+        return
+
+    has_existing = has_start and has_end
+    if has_existing:
+        # Extract existing block (find the versioned start marker)
+        start_idx = existing_content.index(marker_prefix)
+        end_idx = existing_content.index(end_marker) + len(end_marker)
+        existing_block = existing_content[start_idx:end_idx].strip()
+
+        if existing_block == rules_text:
+            console.print("[yellow][-][/yellow] Behavioral rules already configured correctly")
+            return
+        else:
+            # Version upgrade needed
+            console.print("\n[bold]Behavioral rules update available:[/bold]")
+            console.print(f"[dim]{rules_text}[/dim]")
+            if not click.confirm("Update behavioral rules in CLAUDE.md?"):
+                console.print("[yellow][-][/yellow] Skipped behavioral rules update")
+                return
+
+            # Backup before modifying
+            backup_path = claude_md_path.with_suffix(".md.pre-jacked")
+            if not backup_path.exists():
+                shutil.copy2(claude_md_path, backup_path)
+                console.print(f"[dim]Backup: {backup_path}[/dim]")
+
+            # Replace the block (symmetric with _remove_behavioral_rules)
+            before = existing_content[:start_idx].rstrip("\n")
+            after = existing_content[end_idx:].lstrip("\n")
+            if before and after:
+                new_content = before + "\n\n" + rules_text + "\n\n" + after
+            elif before:
+                new_content = before + "\n\n" + rules_text + "\n"
+            else:
+                new_content = rules_text + "\n" + after if after else rules_text + "\n"
+            try:
+                claude_md_path.write_text(new_content, encoding="utf-8")
+            except PermissionError:
+                console.print(f"[red][FAIL][/red] Permission denied writing to {claude_md_path}")
+                console.print("Check file permissions and try again.")
+                return
+            console.print("[green][OK][/green] Updated behavioral rules to latest version")
+            return
+
+    # Fresh install - show and confirm
+    console.print("\n[bold]Proposed behavioral rules for ~/.claude/CLAUDE.md:[/bold]")
+    console.print(f"[dim]{rules_text}[/dim]")
+    if not click.confirm("Add these behavioral rules to your global CLAUDE.md?"):
+        console.print("[yellow][-][/yellow] Skipped behavioral rules")
+        return
+
+    # Backup before modifying (if file exists and no backup yet)
+    if claude_md_path.exists():
+        backup_path = claude_md_path.with_suffix(".md.pre-jacked")
+        if not backup_path.exists():
+            shutil.copy2(claude_md_path, backup_path)
+            console.print(f"[dim]Backup: {backup_path}[/dim]")
+
+    # Ensure parent directory exists
+    claude_md_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Build new content atomically
+    if existing_content and not existing_content.endswith("\n\n"):
+        if existing_content.endswith("\n"):
+            new_content = existing_content + "\n" + rules_text + "\n"
+        else:
+            new_content = existing_content + "\n\n" + rules_text + "\n"
+    else:
+        new_content = existing_content + rules_text + "\n"
+
+    try:
+        claude_md_path.write_text(new_content, encoding="utf-8")
+    except PermissionError:
+        console.print(f"[red][FAIL][/red] Permission denied writing to {claude_md_path}")
+        console.print("Check file permissions and try again.")
+        return
+    console.print("[green][OK][/green] Installed behavioral rules in CLAUDE.md")
+
+
+def _remove_behavioral_rules(claude_md_path: Path) -> bool:
+    """Remove jacked behavioral rules block from CLAUDE.md.
+
+    Returns True if rules were found and removed.
+    """
+    if not claude_md_path.exists():
+        return False
+
+    content = claude_md_path.read_text(encoding="utf-8")
+    marker_prefix = "# jacked-behaviors-v"
+    end_marker = _behavioral_rules_end_marker()
+
+    if marker_prefix not in content or end_marker not in content:
+        return False
+
+    start_idx = content.index(marker_prefix)
+    end_idx = content.index(end_marker) + len(end_marker)
+
+    # Strip the block and any extra blank lines around it
+    before = content[:start_idx].rstrip("\n")
+    after = content[end_idx:].lstrip("\n")
+
+    if before and after:
+        new_content = before + "\n\n" + after
+    elif before:
+        new_content = before + "\n"
+    else:
+        new_content = after
+
+    try:
+        claude_md_path.write_text(new_content, encoding="utf-8")
+    except PermissionError:
+        console.print(f"[red][FAIL][/red] Permission denied writing to {claude_md_path}")
+        return False
+    return True
+
+
+def _security_hook_marker() -> str:
+    """Marker to identify jacked security gatekeeper hooks."""
+    return "# jacked-security"
+
+
+def _get_security_prompt() -> str:
+    """Load security gatekeeper prompt from data file."""
+    prompt_path = _get_data_root() / "prompts" / "security_gatekeeper.txt"
+    if not prompt_path.exists():
+        raise FileNotFoundError(f"Security prompt not found: {prompt_path}")
+    return prompt_path.read_text(encoding="utf-8")
+
+
+def _install_security_hook(existing: dict, settings_path: Path):
+    """Install Opus-powered security gatekeeper hook for Bash commands.
+
+    Handles fresh install and version upgrades (detects stale prompts).
+    """
+    import json
+
+    marker = _security_hook_marker()
+
+    try:
+        prompt_text = _get_security_prompt()
+    except FileNotFoundError as e:
+        console.print(f"[red][FAIL][/red] {e}")
+        console.print("[yellow]Skipping security gatekeeper installation[/yellow]")
+        return
+
+    if "PermissionRequest" not in existing["hooks"]:
+        existing["hooks"]["PermissionRequest"] = []
+
+    # Check if already installed and whether it needs upgrading
+    hook_index = None
+    needs_upgrade = False
+    for i, hook_entry in enumerate(existing["hooks"]["PermissionRequest"]):
+        hook_str = str(hook_entry)
+        if marker in hook_str:
+            hook_index = i
+            # Check if installed prompt matches current version
+            for h in hook_entry.get("hooks", []):
+                installed_prompt = h.get("prompt", "")
+                if installed_prompt != prompt_text:
+                    needs_upgrade = True
+            break
+
+    if hook_index is not None and not needs_upgrade:
+        console.print("[yellow][-][/yellow] Security gatekeeper hook already configured")
+        return
+
+    hook_entry = {
+        "matcher": "Bash",
+        "hooks": [{
+            "type": "prompt",
+            "prompt": prompt_text,
+            "model": "opus",
+            "timeout": 60,
+        }]
+    }
+
+    if hook_index is not None and needs_upgrade:
+        existing["hooks"]["PermissionRequest"][hook_index] = hook_entry
+        settings_path.write_text(json.dumps(existing, indent=2))
+        console.print("[green][OK][/green] Updated security gatekeeper prompt to latest version")
+    else:
+        existing["hooks"]["PermissionRequest"].append(hook_entry)
+        settings_path.parent.mkdir(parents=True, exist_ok=True)
+        settings_path.write_text(json.dumps(existing, indent=2))
+        console.print("[green][OK][/green] Installed security gatekeeper (Opus evaluates Bash commands)")
+
+
+def _remove_security_hook(settings_path: Path) -> bool:
+    """Remove jacked security gatekeeper hook. Returns True if removed."""
+    import json
+
+    if not settings_path.exists():
+        return False
+
+    settings = json.loads(settings_path.read_text())
+    marker = _security_hook_marker()
+
+    if "PermissionRequest" not in settings.get("hooks", {}):
+        return False
+
+    before = len(settings["hooks"]["PermissionRequest"])
+    settings["hooks"]["PermissionRequest"] = [
+        h for h in settings["hooks"]["PermissionRequest"]
+        if marker not in str(h)
+    ]
+    if len(settings["hooks"]["PermissionRequest"]) < before:
+        settings_path.write_text(json.dumps(settings, indent=2))
+        console.print("[green][OK][/green] Removed security gatekeeper hook")
+        return True
+
+    return False
+
+
 @main.command()
 @click.option("--sounds", is_flag=True, help="Install sound notification hooks")
-def install(sounds: bool):
+@click.option("--no-security", is_flag=True, help="Skip security gatekeeper hook")
+@click.option("--no-rules", is_flag=True, help="Skip behavioral rules in CLAUDE.md")
+def install(sounds: bool, no_security: bool, no_rules: bool):
     """Auto-install hook config, skill, agents, and commands."""
     import os
     import json
@@ -692,6 +977,7 @@ def install(sounds: bool):
     pkg_root = _get_data_root()
 
     # Hook configuration - assumes jacked is on PATH (installed via pipx)
+    # async: True runs indexing in background so Claude Code doesn't wait
     hook_config = {
         "hooks": {
             "Stop": [
@@ -700,7 +986,8 @@ def install(sounds: bool):
                     "hooks": [
                         {
                             "type": "command",
-                            "command": 'jacked index --repo "$CLAUDE_PROJECT_DIR"'
+                            "command": 'jacked index --repo "$CLAUDE_PROJECT_DIR"',
+                            "async": True
                         }
                     ]
                 }
@@ -726,19 +1013,31 @@ def install(sounds: bool):
     if "Stop" not in existing["hooks"]:
         existing["hooks"]["Stop"] = []
 
-    # Check if hook already exists
-    hook_exists = any(
-        "jacked" in str(h.get("hooks", []))
-        for h in existing["hooks"]["Stop"]
-    )
-
-    if not hook_exists:
+    # Check if hook already exists and if it needs updating
+    hook_index = None
+    needs_async_update = False
+    for i, hook_entry in enumerate(existing["hooks"]["Stop"]):
+        for h in hook_entry.get("hooks", []):
+            if "jacked" in h.get("command", ""):
+                hook_index = i
+                # Check if async is missing or false
+                if not h.get("async"):
+                    needs_async_update = True
+                break
+
+    if hook_index is None:
+        # No hook exists - add it
         existing["hooks"]["Stop"].append(hook_config["hooks"]["Stop"][0])
         settings_path.parent.mkdir(parents=True, exist_ok=True)
         settings_path.write_text(json.dumps(existing, indent=2))
         console.print(f"[green][OK][/green] Added Stop hook to {settings_path}")
+    elif needs_async_update:
+        # Hook exists but needs async: true
+        existing["hooks"]["Stop"][hook_index] = hook_config["hooks"]["Stop"][0]
+        settings_path.write_text(json.dumps(existing, indent=2))
+        console.print(f"[green][OK][/green] Updated Stop hook with async: true")
     else:
-        console.print(f"[yellow][-][/yellow] Stop hook already exists in {settings_path}")
+        console.print(f"[yellow][-][/yellow] Stop hook already configured correctly")
 
     # Copy skill file with Python path templating
     # Claude Code expects skills in subdirectories with SKILL.md
@@ -754,29 +1053,59 @@ def install(sounds: bool):
     else:
         console.print(f"[yellow][-][/yellow] Skill file not found at {skill_src}")
 
-    # Copy agents
+    # Copy agents (with conflict detection)
     agents_src = pkg_root / "agents"
     agents_dst = home / ".claude" / "agents"
     if agents_src.exists():
         agents_dst.mkdir(parents=True, exist_ok=True)
         agent_count = 0
+        skipped = 0
         for agent_file in agents_src.glob("*.md"):
-            shutil.copy(agent_file, agents_dst / agent_file.name)
+            dst_file = agents_dst / agent_file.name
+            src_content = agent_file.read_text(encoding="utf-8")
+            if dst_file.exists():
+                dst_content = dst_file.read_text(encoding="utf-8")
+                if src_content == dst_content:
+                    skipped += 1
+                    continue  # Same content, skip silently
+                # Different content - ask before overwriting
+                if not click.confirm(f"Agent '{agent_file.name}' exists with different content. Overwrite?"):
+                    console.print(f"[yellow][-][/yellow] Skipped {agent_file.name}")
+                    continue
+            shutil.copy(agent_file, dst_file)
             agent_count += 1
-        console.print(f"[green][OK][/green] Installed {agent_count} agents")
+        msg = f"[green][OK][/green] Installed {agent_count} agents"
+        if skipped:
+            msg += f" ({skipped} unchanged)"
+        console.print(msg)
     else:
         console.print(f"[yellow][-][/yellow] Agents directory not found")
 
-    # Copy commands
+    # Copy commands (with conflict detection)
     commands_src = pkg_root / "commands"
     commands_dst = home / ".claude" / "commands"
     if commands_src.exists():
         commands_dst.mkdir(parents=True, exist_ok=True)
         cmd_count = 0
+        skipped = 0
         for cmd_file in commands_src.glob("*.md"):
-            shutil.copy(cmd_file, commands_dst / cmd_file.name)
+            dst_file = commands_dst / cmd_file.name
+            src_content = cmd_file.read_text(encoding="utf-8")
+            if dst_file.exists():
+                dst_content = dst_file.read_text(encoding="utf-8")
+                if src_content == dst_content:
+                    skipped += 1
+                    continue  # Same content, skip silently
+                # Different content - ask before overwriting
+                if not click.confirm(f"Command '{cmd_file.name}' exists with different content. Overwrite?"):
+                    console.print(f"[yellow][-][/yellow] Skipped {cmd_file.name}")
+                    continue
+            shutil.copy(cmd_file, dst_file)
             cmd_count += 1
-        console.print(f"[green][OK][/green] Installed {cmd_count} commands")
+        msg = f"[green][OK][/green] Installed {cmd_count} commands"
+        if skipped:
+            msg += f" ({skipped} unchanged)"
+        console.print(msg)
     else:
         console.print(f"[yellow][-][/yellow] Commands directory not found")
 
@@ -784,13 +1113,30 @@ def install(sounds: bool):
     if sounds:
         _install_sound_hooks(existing, settings_path)
 
+    # Install security gatekeeper (default on, --no-security to skip)
+    if not no_security:
+        _install_security_hook(existing, settings_path)
+
+    # Install behavioral rules in CLAUDE.md (default on, --no-rules to skip)
+    if not no_rules:
+        claude_md_path = home / ".claude" / "CLAUDE.md"
+        _install_behavioral_rules(claude_md_path)
+
     console.print("\n[bold]Installation complete![/bold]")
     console.print("\n[yellow]IMPORTANT: Restart Claude Code for new commands to take effect![/yellow]")
     console.print("\nWhat you get:")
     console.print("  - /jacked - Search past Claude sessions")
-    console.print("  - /dc - Double-check reviewer")
+    console.print("  - /dc - Double-check reviewer (with grill mode)")
     console.print("  - /pr - PR workflow helper")
+    console.print("  - /learn - Distill lessons into CLAUDE.md rules")
+    console.print("  - /techdebt - Project tech debt audit")
+    console.print("  - /redo - Scrap and re-implement with hindsight")
+    console.print("  - /audit-rules - CLAUDE.md quality audit")
     console.print("  - 10 specialized agents (readme, wiki, tests, etc.)")
+    if not no_security:
+        console.print("  - Security gatekeeper (Opus evaluates Bash commands)")
+    if not no_rules:
+        console.print("  - Behavioral rules in CLAUDE.md (auto-triggers for jacked commands)")
     console.print("\nNext steps:")
     console.print("  1. Restart Claude Code (exit and run 'claude' again)")
     console.print("  2. Set environment variables (run 'jacked configure' for help)")
@@ -801,7 +1147,9 @@ def install(sounds: bool):
 @main.command()
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation")
 @click.option("--sounds", is_flag=True, help="Remove only sound hooks")
-def uninstall(yes: bool, sounds: bool):
+@click.option("--security", is_flag=True, help="Remove only security gatekeeper hook")
+@click.option("--rules", is_flag=True, help="Remove only behavioral rules from CLAUDE.md")
+def uninstall(yes: bool, sounds: bool, security: bool, rules: bool):
     """Remove jacked hooks, skill, agents, and commands from Claude Code."""
     import json
     import shutil
@@ -818,6 +1166,23 @@ def uninstall(yes: bool, sounds: bool):
             console.print("[yellow]No sound hooks found[/yellow]")
         return
 
+    # If --security flag, only remove security hook
+    if security:
+        if _remove_security_hook(settings_path):
+            console.print("[bold]Security gatekeeper removed![/bold]")
+        else:
+            console.print("[yellow]No security gatekeeper hook found[/yellow]")
+        return
+
+    # If --rules flag, only remove behavioral rules
+    if rules:
+        claude_md_path = home / ".claude" / "CLAUDE.md"
+        if _remove_behavioral_rules(claude_md_path):
+            console.print("[bold]Behavioral rules removed from CLAUDE.md![/bold]")
+        else:
+            console.print("[yellow]No behavioral rules found in CLAUDE.md[/yellow]")
+        return
+
     if not yes:
         if not click.confirm("Remove jacked from Claude Code? (This won't delete your Qdrant index)"):
             console.print("Cancelled")
@@ -825,8 +1190,12 @@ def uninstall(yes: bool, sounds: bool):
 
     console.print("[bold]Uninstalling Jacked...[/bold]\n")
 
-    # Also remove sound hooks during full uninstall
+    # Also remove sound, security hooks, and behavioral rules during full uninstall
     _remove_sound_hooks(settings_path)
+    _remove_security_hook(settings_path)
+    claude_md_path = home / ".claude" / "CLAUDE.md"
+    if _remove_behavioral_rules(claude_md_path):
+        console.print("[green][OK][/green] Removed behavioral rules from CLAUDE.md")
 
     # Remove Stop hook from settings.json
     if settings_path.exists():

jacked/client.py

@@ -55,11 +55,13 @@ class QdrantSessionClient:
 
     def ensure_collection(self) -> bool:
         """
-        Ensure the collection exists, creating it if necessary.
+        Ensure the collection exists with all required indexes.
 
         Creates collection with:
         - Dense vectors for semantic search
-        - Payload indexing for repo filtering
+        - Payload indexing for filtering
+
+        Also ensures indexes exist on existing collections (for upgrades).
 
         Returns:
             True if collection exists or was created
@@ -75,7 +77,9 @@ class QdrantSessionClient:
             exists = any(c.name == collection_name for c in collections.collections)
 
             if exists:
-                logger.info(f"Collection '{collection_name}' already exists")
+                logger.debug(f"Collection '{collection_name}' already exists")
+                # Ensure indexes exist (handles upgrades)
+                self._ensure_indexes(collection_name)
                 return True
 
             logger.info(f"Creating collection '{collection_name}'")
@@ -134,6 +138,30 @@ class QdrantSessionClient:
             logger.error(f"Failed to create collection: {e}")
             raise
 
+    def _ensure_indexes(self, collection_name: str):
+        """
+        Ensure all required payload indexes exist on a collection.
+
+        Creates indexes if they don't exist (idempotent).
+        """
+        required_indexes = [
+            "repo_id", "repo_name", "session_id", "type",
+            "machine", "user_name", "content_type"
+        ]
+
+        for field_name in required_indexes:
+            try:
+                self.client.create_payload_index(
+                    collection_name=collection_name,
+                    field_name=field_name,
+                    field_schema=models.PayloadSchemaType.KEYWORD,
+                )
+                logger.debug(f"Created index for '{field_name}'")
+            except UnexpectedResponse as e:
+                # Index might already exist - that's fine
+                if "already exists" not in str(e).lower():
+                    logger.warning(f"Could not create index for '{field_name}': {e}")
+
     def upsert_points(self, points: list[models.PointStruct]) -> bool:
         """
         Upsert points to the collection.
@@ -192,6 +220,48 @@ class QdrantSessionClient:
             logger.error(f"Failed to delete session {session_id}: {e}")
             raise
 
+    def get_session_points(self, session_id: str, user_name: str) -> list:
+        """
+        Get all points for a session owned by this user (for write tracker seeding).
+
+        IMPORTANT: Filters by BOTH session_id AND user_name to ensure we only
+        see our own data. This is for write-side tracking only - not for retrieval.
+
+        Args:
+            session_id: Session UUID
+            user_name: User name to filter by
+
+        Returns:
+            List of Qdrant points with payloads (no vectors)
+        """
+        points = []
+        offset = None
+        while True:
+            result = self.client.scroll(
+                collection_name=self.config.collection_name,
+                scroll_filter=models.Filter(
+                    must=[
+                        models.FieldCondition(
+                            key="session_id",
+                            match=models.MatchValue(value=session_id)
+                        ),
+                        models.FieldCondition(
+                            key="user_name",
+                            match=models.MatchValue(value=user_name)
+                        )
+                    ]
+                ),
+                limit=100,
+                offset=offset,
+                with_payload=True,
+                with_vectors=False,  # Don't need vectors, just metadata
+            )
+            points.extend(result[0])
+            offset = result[1]
+            if offset is None:
+                break
+        return points
+
     def delete_by_user(self, user_name: str) -> int:
         """
         Delete all points for a specific user.
@@ -387,28 +457,6 @@ class QdrantSessionClient:
             logger.error(f"Failed to get points for session {session_id}: {e}")
             raise
 
-    def get_point_by_id(self, point_id: str) -> Optional[models.Record]:
-        """
-        Get a single point by ID.
-
-        Args:
-            point_id: Point ID to retrieve
-
-        Returns:
-            Record object or None if not found
-        """
-        try:
-            results = self.client.retrieve(
-                collection_name=self.config.collection_name,
-                ids=[point_id],
-                with_payload=True,
-                with_vectors=False,
-            )
-            return results[0] if results else None
-        except UnexpectedResponse as e:
-            logger.error(f"Failed to get point {point_id}: {e}")
-            return None
-
     def list_sessions(
         self,
         repo_id: Optional[str] = None,
@@ -424,10 +472,11 @@ class QdrantSessionClient:
         Returns:
             List of session metadata dicts
         """
+        # Filter by plan content_type - one per session, gives unique sessions
         filter_conditions = [
             models.FieldCondition(
-                key="type",
-                match=models.MatchValue(value="intent"),
+                key="content_type",
+                match=models.MatchValue(value="plan"),
             )
         ]
 
@@ -455,9 +504,10 @@ class QdrantSessionClient:
                     "session_id": payload.get("session_id"),
                     "repo_name": payload.get("repo_name"),
                     "repo_path": payload.get("repo_path"),
+                    "user_name": payload.get("user_name"),
                     "machine": payload.get("machine"),
                     "timestamp": payload.get("timestamp"),
-                    "chunk_count": payload.get("transcript_chunk_count", 0),
+                    "chunk_count": payload.get("total_chunks", 0),
                 })
 
             return sessions