repr-cli 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

repr/cli.py

@@ -21,10 +21,11 @@ import os
 import sys
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Optional, List, Dict, Callable
+from typing import Optional, List, Dict, Callable, Any, Any
 from collections import defaultdict
 
 import typer
+from rich.markup import escape as rich_escape
 from rich.prompt import Confirm, Prompt
 from rich.table import Table
 
@@ -86,9 +87,6 @@ from .config import (
 )
 from .storage import (
     save_story,
-    load_story,
-    delete_story,
-    list_stories,
     get_story_count,
     get_unpushed_stories,
     mark_story_pushed,
@@ -98,9 +96,245 @@ from .storage import (
     restore_from_backup,
     get_storage_stats,
 )
+from .db import get_db
 from .auth import AuthFlow, AuthError, logout as auth_logout, get_current_user, migrate_plaintext_auth
 from .api import APIError
 
+
+# Database-backed story listing (replaces JSON storage)
+def list_stories(
+    repo_name: str | None = None,
+    since: datetime | None = None,
+    needs_review: bool = False,
+    limit: int | None = None,
+) -> list[dict[str, Any]]:
+    """
+    List all stories from the database.
+
+    Args:
+        repo_name: Filter by repository name
+        since: Filter by creation date
+        needs_review: Only show stories needing review
+        limit: Maximum stories to return
+
+    Returns:
+        List of story metadata dicts (sorted by creation date, newest first)
+    """
+    db = get_db()
+
+    # Build query with project join
+    conditions = []
+    params = []
+
+    if since:
+        iso_since = since.isoformat()
+        conditions.append("s.created_at >= ?")
+        params.append(iso_since)
+
+    where_clause = " AND ".join(conditions) if conditions else "1=1"
+
+    query = f"""
+        SELECT
+            s.id,
+            s.project_id,
+            s.created_at,
+            s.updated_at,
+            s.title,
+            s.problem,
+            s.approach,
+            s.tradeoffs,
+            s.outcome,
+            s.category,
+            s.scope,
+            s.technologies,
+            s.started_at,
+            s.ended_at,
+            s.implementation_details,
+            s.decisions,
+            s.lessons,
+            s.hook,
+            s.what,
+            s.value,
+            s.insight,
+            s.show,
+            s.diagram,
+            s.post_body,
+            p.name as repo_name,
+            p.path as repo_path
+        FROM stories s
+        JOIN projects p ON s.project_id = p.id
+        WHERE {where_clause}
+        ORDER BY s.created_at DESC
+    """
+
+    if limit:
+        query += " LIMIT ?"
+        params.append(limit)
+
+    stories = []
+    with db.connect() as conn:
+        for row in conn.execute(query, params).fetchall():
+            story = {
+                "id": row["id"],
+                "repo_name": row["repo_name"],
+                "repo_path": row["repo_path"],
+                "summary": row["title"],
+                "created_at": row["created_at"],
+                "updated_at": row["updated_at"],
+                "problem": row["problem"],
+                "approach": row["approach"],
+                "tradeoffs": row["tradeoffs"],
+                "outcome": row["outcome"],
+                "category": row["category"],
+                "scope": row["scope"],
+                "started_at": row["started_at"],
+                "ended_at": row["ended_at"],
+                "hook": row["hook"],
+                "what": row["what"],
+                "value": row["value"],
+                "insight": row["insight"],
+                "show": row["show"],
+                "diagram": row["diagram"],
+                "post_body": row["post_body"],
+            }
+
+            # Deserialize JSON fields
+            if row["technologies"]:
+                try:
+                    story["technologies"] = json.loads(row["technologies"])
+                except json.JSONDecodeError:
+                    story["technologies"] = []
+            else:
+                story["technologies"] = []
+
+            if row["implementation_details"]:
+                try:
+                    story["implementation_details"] = json.loads(row["implementation_details"])
+                except json.JSONDecodeError:
+                    story["implementation_details"] = []
+            else:
+                story["implementation_details"] = []
+
+            if row["decisions"]:
+                try:
+                    story["decisions"] = json.loads(row["decisions"])
+                except json.JSONDecodeError:
+                    story["decisions"] = []
+            else:
+                story["decisions"] = []
+
+            if row["lessons"]:
+                try:
+                    story["lessons"] = json.loads(row["lessons"])
+                except json.JSONDecodeError:
+                    story["lessons"] = []
+            else:
+                story["lessons"] = []
+
+            # Apply filters that couldn't be in SQL
+            if repo_name and story["repo_name"] != repo_name:
+                continue
+
+            if needs_review and not story.get("needs_review", False):
+                continue
+
+            stories.append(story)
+
+    return stories
+
+
+def load_story(story_id: str) -> tuple[str, dict[str, Any]] | None:
+    """
+    Load a story by ID from the database.
+
+    Args:
+        story_id: Story ULID
+
+    Returns:
+        Tuple of (content, metadata) or None if not found
+    """
+    db = get_db()
+    story = db.get_story(story_id)
+
+    if not story:
+        return None
+
+    # Convert Story model to markdown content
+    content = f"""# {story.title}
+
+## Problem
+{story.problem or "No problem specified."}
+
+## Approach
+{story.approach or "No approach specified."}
+
+## Tradeoffs
+{story.tradeoffs or "No tradeoffs specified."}
+
+## Outcome
+{story.outcome or "No outcome specified."}
+
+## Implementation Details
+{chr(10).join(f"- {d}" for d in story.implementation_details) if story.implementation_details else "None"}
+
+## Decisions
+{chr(10).join(f"- {d}" for d in story.decisions) if story.decisions else "None"}
+
+## Lessons
+{chr(10).join(f"- {l}" for l in story.lessons) if story.lessons else "None"}
+
+## Technologies
+{chr(10).join(f"- {t}" for t in story.technologies) if story.technologies else "None"}
+"""
+
+    # Build metadata dict (for backward compatibility)
+    metadata = {
+        "id": story.id,
+        "title": story.title,
+        "summary": story.title,  # For compatibility
+        "problem": story.problem,
+        "approach": story.approach,
+        "tradeoffs": story.tradeoffs,
+        "outcome": story.outcome,
+        "category": story.category,
+        "scope": story.scope,
+        "created_at": story.created_at.isoformat() if story.created_at else None,
+        "updated_at": story.updated_at.isoformat() if story.updated_at else None,
+        "started_at": story.started_at.isoformat() if story.started_at else None,
+        "ended_at": story.ended_at.isoformat() if story.ended_at else None,
+        "technologies": story.technologies,
+        "implementation_details": story.implementation_details,
+        "decisions": story.decisions,
+        "lessons": story.lessons,
+        "files": story.files,
+        "commit_shas": story.commit_shas,
+        "session_ids": story.session_ids,
+        "hook": story.hook,
+        "what": story.what,
+        "value": story.value,
+        "insight": story.insight,
+        "show": story.show,
+        "diagram": story.diagram,
+        "post_body": story.post_body,
+    }
+
+    return content, metadata
+
+
+def delete_story(story_id: str) -> bool:
+    """
+    Delete a story by ID from the database.
+
+    Args:
+        story_id: Story ULID
+
+    Returns:
+        True if deleted, False if not found
+    """
+    db = get_db()
+    return db.delete_story(story_id)
+
+
 # Create Typer app
 app = typer.Typer(
     name="repr",
@@ -111,18 +345,30 @@ app = typer.Typer(
 
 # Sub-apps for command groups
 hooks_app = typer.Typer(help="Manage git post-commit hooks")
+cron_app = typer.Typer(help="Scheduled story generation (every 4h)")
 llm_app = typer.Typer(help="Configure LLM (local/cloud/BYOK)")
 privacy_app = typer.Typer(help="Privacy audit and controls")
 config_app = typer.Typer(help="View and modify configuration")
 data_app = typer.Typer(help="Backup, restore, and manage data")
 profile_app = typer.Typer(help="View and manage profile")
+mcp_app = typer.Typer(help="MCP server for AI agent integration")
+timeline_app = typer.Typer(help="Unified timeline of commits + AI sessions")
+friends_app = typer.Typer(help="Manage friends")
+skill_app = typer.Typer(help="Manage repr skill for AI agents")
+configure_app = typer.Typer(help="Configure repr (LLM, repos, schedule)")
 
 app.add_typer(hooks_app, name="hooks")
+app.add_typer(cron_app, name="cron")
 app.add_typer(llm_app, name="llm")
 app.add_typer(privacy_app, name="privacy")
 app.add_typer(config_app, name="config")
 app.add_typer(data_app, name="data")
 app.add_typer(profile_app, name="profile")
+app.add_typer(mcp_app, name="mcp")
+app.add_typer(timeline_app, name="timeline")
+app.add_typer(friends_app, name="friends")
+app.add_typer(skill_app, name="skill")
+app.add_typer(configure_app, name="configure")
 
 
 def version_callback(value: bool):
@@ -153,18 +399,147 @@ def main(
     ),
 ):
     """repr - understand what you've actually worked on.
-    
+
     Cloud features require sign-in. Local generation always works offline.
     """
     # Migrate plaintext auth tokens on startup
     migrate_plaintext_auth()
-    
+
+    # First-run detection: trigger wizard on first use
+    # Skip for: configure, --help, mcp (automated), CI, non-interactive
+    skip_first_run_commands = {"configure", "mcp", None}
+    if ctx.invoked_subcommand not in skip_first_run_commands:
+        import os
+        is_ci = os.getenv("CI") or os.getenv("GITHUB_ACTIONS") or os.getenv("REPR_CI")
+        is_interactive = sys.stdin.isatty() if hasattr(sys.stdin, 'isatty') else False
+        if is_interactive and not is_ci:
+            from .configure import is_first_run, run_full_wizard
+            if is_first_run():
+                run_full_wizard()
+
     # Track command usage (if telemetry enabled)
     from .telemetry import track_command
     if ctx.invoked_subcommand:
         track_command(ctx.invoked_subcommand)
 
 
+# =============================================================================
+# DASHBOARD
+# =============================================================================
+
+@app.command("dashboard")
+def dashboard(
+    port: int = typer.Option(
+        8787, "--port", "-p",
+        help="Port to serve on",
+    ),
+    host: str = typer.Option(
+        "127.0.0.1", "--host",
+        help="Host to bind to",
+    ),
+    open_browser: bool = typer.Option(
+        True, "--open/--no-open",
+        help="Auto-open browser (default: enabled)",
+    ),
+):
+    """
+    Launch web dashboard for exploring your stories.
+
+    Starts a local web server to browse and search through your
+    stories with rich context visualization.
+
+    Works from any directory - reads from central SQLite database.
+
+    Examples:
+        repr dashboard              # localhost:8787, auto-opens browser
+        repr dashboard --port 8080  # custom port
+        repr dashboard --no-open    # don't auto-open browser
+        rp dashboard                # using the 'rp' alias
+    """
+    import webbrowser
+    from .dashboard import run_server
+    from .db import get_db_path, get_db
+
+    # Check if SQLite database exists and has stories
+    if not get_db_path().exists():
+        print_error("No stories database found")
+        print_info("Run `repr generate` in a git repository first")
+        raise typer.Exit(1)
+
+    db = get_db()
+    stats = db.get_stats()
+    story_count = stats.get("story_count", 0)
+    project_count = stats.get("project_count", 0)
+
+    if story_count == 0:
+        print_error("No stories in database")
+        print_info("Run `repr generate` to create stories from commits")
+        raise typer.Exit(1)
+
+    console.print(f"Starting dashboard with [bold]{story_count} stories[/] from [bold]{project_count} repositories[/]")
+
+    # Ensure dashboard is built (build on the fly if needed)
+    _ensure_dashboard_built()
+
+    url = f"http://{host}:{port}"
+
+    print_header()
+    console.print(f"  URL: [bold blue]{url}[/]")
+    console.print()
+    console.print("[dim]Press Ctrl+C to stop[/]")
+    console.print()
+
+    if open_browser:
+        webbrowser.open(url)
+
+    try:
+        run_server(port, host)
+    except KeyboardInterrupt:
+        console.print()
+        print_info("Server stopped")
+    except OSError as e:
+        if "Address already in use" in str(e):
+            print_error(f"Port {port} is already in use")
+            print_info(f"Try: repr dashboard --port {port + 1}")
+        raise
+
+
+def _ensure_dashboard_built():
+    """Build dashboard if index.html doesn't exist or source files are newer."""
+    from pathlib import Path
+
+    dashboard_dir = Path(__file__).parent / "dashboard"
+    src_dir = dashboard_dir / "src"
+    index_html = dashboard_dir / "index.html"
+
+    # If no source directory, can't build
+    if not src_dir.exists():
+        return
+
+    # Check if we need to build
+    needs_build = False
+
+    if not index_html.exists():
+        needs_build = True
+        reason = "index.html not found"
+    else:
+        # Check if any source file is newer than index.html
+        index_mtime = index_html.stat().st_mtime
+
+        for src_file in src_dir.rglob("*"):
+            if src_file.is_file() and src_file.stat().st_mtime > index_mtime:
+                needs_build = True
+                reason = f"{src_file.relative_to(dashboard_dir)} is newer than index.html"
+                break
+
+    if needs_build:
+        from .dashboard.build import build
+        print_info(f"Building dashboard ({reason})...")
+        result = build()
+        if result != 0:
+            print_warning("Dashboard build failed, using cached version if available")
+
+
 # =============================================================================
 # INIT
 # =============================================================================
@@ -236,7 +611,65 @@ def init(
         console.print(f"Local LLM: detected {llm_info.name} at {llm_info.url}")
     else:
         console.print(f"[{BRAND_MUTED}]Local LLM: not detected (install Ollama for offline generation)[/]")
-    
+
+    # Ask about automatic story generation
+    console.print()
+    console.print("[bold]Automatic Story Generation[/]")
+    console.print()
+    console.print("How should repr generate stories from your commits?")
+    console.print()
+    console.print(f"  [bold]1.[/] Scheduled (recommended) - Every 4 hours via cron")
+    console.print(f"     [{BRAND_MUTED}]Predictable, batches work, never interrupts[/]")
+    console.print()
+    console.print(f"  [bold]2.[/] On commit - After every 5 commits via git hook")
+    console.print(f"     [{BRAND_MUTED}]Real-time, but needs LLM running during commits[/]")
+    console.print()
+    console.print(f"  [bold]3.[/] Manual only - Run `repr generate` yourself")
+    console.print(f"     [{BRAND_MUTED}]Full control, no automation[/]")
+    console.print()
+
+    schedule_choice = Prompt.ask(
+        "Choose",
+        choices=["1", "2", "3"],
+        default="1",
+    )
+
+    from .hooks import install_hook
+    from .cron import install_cron
+
+    if schedule_choice == "1":
+        # Scheduled via cron
+        result = install_cron(interval_hours=4, min_commits=3)
+        if result["success"]:
+            print_success("Cron job installed (every 4h)")
+            # Install hooks for queue tracking (but disable auto-generate)
+            config = load_config()
+            config["generation"]["auto_generate_on_hook"] = False
+            save_config(config)
+            for repo in repos:
+                install_hook(Path(repo.path))
+                set_repo_hook_status(str(repo.path), True)
+        else:
+            print_warning(f"Could not install cron: {result['message']}")
+            print_info("You can set it up later with `repr cron install`")
+
+    elif schedule_choice == "2":
+        # On-commit via hooks
+        config = load_config()
+        config["generation"]["auto_generate_on_hook"] = True
+        save_config(config)
+        for repo in repos:
+            install_hook(Path(repo.path))
+            set_repo_hook_status(str(repo.path), True)
+        print_success(f"Hooks installed in {len(repos)} repos (generates after 5 commits)")
+
+    else:
+        # Manual only - disable auto-generation
+        config = load_config()
+        config["generation"]["auto_generate_on_hook"] = False
+        save_config(config)
+        print_info("Manual mode - run `repr generate` when you want stories")
+
     console.print()
     print_next_steps([
         "repr week               See what you worked on this week",
@@ -249,6 +682,90 @@ def init(
 # GENERATE
 # =============================================================================
 
+# Technology detection from file extensions
+_TECH_EXTENSIONS = {
+    ".py": "Python",
+    ".ts": "TypeScript",
+    ".tsx": "TypeScript",
+    ".js": "JavaScript",
+    ".jsx": "JavaScript",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".java": "Java",
+    ".kt": "Kotlin",
+    ".swift": "Swift",
+    ".c": "C",
+    ".cpp": "C++",
+    ".h": "C",
+    ".hpp": "C++",
+    ".rb": "Ruby",
+    ".php": "PHP",
+    ".cs": "C#",
+    ".scala": "Scala",
+    ".vue": "Vue",
+    ".svelte": "Svelte",
+    ".sql": "SQL",
+    ".sh": "Shell",
+    ".bash": "Shell",
+    ".yaml": "YAML",
+    ".yml": "YAML",
+    ".json": "JSON",
+    ".graphql": "GraphQL",
+    ".prisma": "Prisma",
+}
+
+# Special file name patterns that indicate technologies
+_TECH_FILES = {
+    "Dockerfile": "Docker",
+    "docker-compose": "Docker",
+    "package.json": "Node.js",
+    "tsconfig.json": "TypeScript",
+    "pyproject.toml": "Python",
+    "requirements.txt": "Python",
+    "Cargo.toml": "Rust",
+    "go.mod": "Go",
+    "Gemfile": "Ruby",
+    "pom.xml": "Maven",
+    "build.gradle": "Gradle",
+    ".eslintrc": "ESLint",
+    "tailwind.config": "Tailwind CSS",
+    "next.config": "Next.js",
+    "vite.config": "Vite",
+    "webpack.config": "Webpack",
+}
+
+
+def _detect_technologies_from_files(files: list[str]) -> list[str]:
+    """
+    Detect technologies from file paths/extensions.
+
+    Args:
+        files: List of file paths
+
+    Returns:
+        Sorted list of detected technology names
+    """
+    tech = set()
+
+    for f in files:
+        # Handle files as either dict with 'path' or string
+        if isinstance(f, dict):
+            f = f.get("path", "")
+
+        # Check extensions
+        for ext, name in _TECH_EXTENSIONS.items():
+            if f.endswith(ext):
+                tech.add(name)
+                break
+
+        # Check special file names
+        for fname, name in _TECH_FILES.items():
+            if fname in f:
+                tech.add(name)
+
+    return sorted(tech)
+
+
 def _parse_date_reference(date_str: str) -> str | None:
     """
     Parse a date reference string into an ISO date string.
@@ -372,10 +889,18 @@ def generate(
         False, "--json",
         help="Output as JSON",
     ),
+    force: bool = typer.Option(
+        False, "--force", "-f",
+        help="Reprocess commits even if already in existing stories",
+    ),
+    with_sessions: bool = typer.Option(
+        True, "--with-sessions/--no-sessions", "-s",
+        help="Include AI session context (Claude Code, Clawdbot)",
+    ),
 ):
     """
     Generate stories from commits.
-    
+
     Examples:
         repr generate --local
         repr generate --cloud
@@ -383,8 +908,16 @@ def generate(
         repr generate --days 30
         repr generate --template changelog
         repr generate --commits abc123,def456
+        repr generate --force  # Reprocess all commits
     """
+    import asyncio
+    from .timeline import extract_commits_from_git, detect_project_root, get_session_contexts_for_commits
+    from .story_synthesis import synthesize_stories
+    from .db import get_db
     from .privacy import check_cloud_permission, log_cloud_operation
+
+    def synthesize_stories_sync(*args, **kwargs):
+        return asyncio.run(synthesize_stories(*args, **kwargs))
     
     # Determine mode
     if cloud:
@@ -401,10 +934,16 @@ def generate(
             raise typer.Exit(1)
     
     if not local and not cloud:
-        # Default: local if not signed in, cloud if signed in
-        if is_authenticated() and is_cloud_allowed():
+        # Check config for default mode
+        llm_config = get_llm_config()
+        default_mode = llm_config.get("default", "local")
+
+        if default_mode == "local":
+            local = True
+        elif default_mode == "cloud" and is_authenticated() and is_cloud_allowed():
             cloud = True
         else:
+            # Fallback: local if not signed in or cloud not allowed
             local = True
     
     if not json_output:
@@ -451,201 +990,193 @@ def generate(
     from .tools import get_commits_with_diffs, get_commits_by_shas
     from .discovery import analyze_repo
     
-    total_stories = 0
-    all_stories = []  # Collect all generated stories for JSON output
-    
+    all_generated_stories = []
+
     for repo_path in repo_paths:
-        repo_info = analyze_repo(repo_path)
         if not json_output:
-            console.print(f"[bold]{repo_info.name}[/]")
-        
+            console.print(f"[bold]{repo_path.name}[/]")
+            
+        # Determine commit range
+        repo_commits = []
         if commits:
-            # Specific commits
-            if not json_output:
-                console.print(f"  Collecting specified commits...")
-            commit_shas = [s.strip() for s in commits.split(",")]
-            commit_list = get_commits_by_shas(repo_path, commit_shas)
+             # Specific SHA list filtering
+             repo_commits = extract_commits_from_git(repo_path, days=90)
+             target_shas = [s.strip() for s in commits.split(",")]
+             repo_commits = [c for c in repo_commits if any(c.sha.startswith(t) for t in target_shas)]
+        elif since_date:
+             # Parse date (rough approximation)
+             filter_days = 30
+             if "week" in since_date: filter_days = 14
+             if "month" in since_date: filter_days = 30
+             repo_commits = extract_commits_from_git(repo_path, days=filter_days)
         else:
-            # Determine timeframe
-            timeframe_days = days if days is not None else 90  # Default 90 days
-            since_str = None
-            
-            # Parse natural language date if provided
-            if since_date:
-                since_str = _parse_date_reference(since_date)
-            
-            # Recent commits within timeframe
-            if not json_output:
-                console.print(f"  Scanning commits...")
-            commit_list = get_commits_with_diffs(
-                repo_path, 
-                count=500,  # Higher limit when filtering by time
-                days=timeframe_days,
-                since=since_str,
-            )
-            if not json_output and commit_list:
-                console.print(f"  Found {len(commit_list)} commits")
-        
-        if not commit_list:
+             filter_days = days if days else 90
+             repo_commits = extract_commits_from_git(repo_path, days=filter_days)
+
+        if not repo_commits:
             if not json_output:
-                console.print(f"  [{BRAND_MUTED}]No commits found[/]")
+                console.print(f"  No matching commits found")
             continue
-        
-        # Filter out already-processed commits
-        from .storage import get_processed_commit_shas
-        processed_shas = get_processed_commit_shas(repo_name=repo_info.name)
-        
-        original_count = len(commit_list)
-        commit_list = [c for c in commit_list if c["full_sha"] not in processed_shas]
-        
-        if not json_output and processed_shas:
-            skipped_count = original_count - len(commit_list)
-            if skipped_count > 0:
-                console.print(f"  [{BRAND_MUTED}]Skipping {skipped_count} already-processed commits[/]")
-        
-        if not commit_list:
+
+        # Filter out commits that are already part of existing stories (unless --force)
+        from .db import get_db
+        db = get_db()
+        project_id = db.register_project(repo_path, repo_path.name)
+        processed_shas = db.get_processed_commits(project_id)
+        if processed_shas and not force:
+            original_count = len(repo_commits)
+            repo_commits = [c for c in repo_commits if c.sha not in processed_shas]
+            skipped = original_count - len(repo_commits)
+            if skipped > 0 and not json_output:
+                console.print(f"  [{BRAND_MUTED}]Skipping {skipped} already-processed commits[/]")
+
+        if not repo_commits:
             if not json_output:
-                console.print(f"  [{BRAND_MUTED}]All commits already processed[/]")
+                console.print(f"  No new commits to process")
             continue
-        
-        # Dry run: show what would be sent
-        if dry_run:
-            from .openai_analysis import estimate_tokens, get_batch_size
-            from .config import load_config
-
-            config = load_config()
-            max_commits = config.get("generation", {}).get("max_commits_per_batch", 50)
-            token_limit = config.get("generation", {}).get("token_limit", 100000)
 
-            console.print(f"  [bold]Dry Run Preview[/]")
-            console.print(f"  Commits to analyze: {len(commit_list)}")
-            console.print(f"  Template: {template}")
-            console.print()
+        if not json_output:
+             console.print(f"  Analyzing {len(repo_commits)} commits...")
 
-            # Estimate tokens
-            estimated_tokens = estimate_tokens(commit_list)
-            console.print(f"  Estimated tokens: ~{estimated_tokens:,}")
+        # Load sessions if requested
+        repo_sessions = None
+        if with_sessions:
+            if not json_output:
+                console.print(f"  Looking for AI sessions...")
+            
+            # Use same days lookback as commits
+            session_days = days if days else 90
+            
+            def session_progress(stage: str, current: int, total: int) -> None:
+                if not json_output:
+                    if stage == "extracting":
+                        console.print(f"  Extracting session {current}/{total}...", end="\r")
+                    elif stage == "sessions_loaded" and current > 0:
+                        console.print(f"  Found {current} sessions")
+            
+            try:
+                # Run async extraction in sync context
+                repo_sessions = asyncio.run(get_session_contexts_for_commits(
+                    repo_path,
+                    repo_commits,
+                    days=session_days,
+                    progress_callback=session_progress
+                ))
+                if not json_output and repo_sessions:
+                    console.print(f"\n  Enriched with {len(repo_sessions)} AI sessions")
+            except Exception as e:
+                if not json_output:
+                    print_warning(f"  Failed to load sessions: {e}")
 
-            # Check if we need to split into batches
-            if len(commit_list) > max_commits:
-                num_batches = (len(commit_list) + max_commits - 1) // max_commits
-                console.print()
-                console.print(f"  ⚠ {len(commit_list)} commits exceeds {max_commits}-commit limit")
-                console.print()
-                console.print(f"  Will split into {num_batches} batches:")
-                for batch_num in range(num_batches):
-                    start = batch_num * max_commits + 1
-                    end = min((batch_num + 1) * max_commits, len(commit_list))
-                    batch_commits = commit_list[batch_num * max_commits:end]
-                    batch_tokens = estimate_tokens(batch_commits)
-                    console.print(f"    Batch {batch_num + 1}: commits {start}-{end} (est. {batch_tokens // 1000}k tokens)")
+        # Progress callback
+        def progress(current: int, total: int) -> None:
+             if not json_output:
+                 console.print(f"  Batch {current}/{total}")
 
-            console.print()
-            console.print("  Sample commits:")
-            for c in commit_list[:5]:
-                console.print(f"    • {c['sha'][:7]} {c['message'][:50]}")
-            if len(commit_list) > 5:
-                console.print(f"    ... and {len(commit_list) - 5} more")
-            continue
-        
-        # Check token limits and prompt user if needed
-        from .openai_analysis import estimate_tokens
-        from .config import load_config
+        # Determine model based on mode (respect config default if no flag given)
+        llm_config = get_llm_config()
+        use_local = local or (not cloud and llm_config.get("default") == "local")
+        if use_local:
+            model = llm_config.get("local_model") or "llama3.2"
+        else:
+            model = None  # Use default cloud model
 
-        config = load_config()
-        max_commits = config.get("generation", {}).get("max_commits_per_batch", 50)
-        token_limit = config.get("generation", {}).get("token_limit", 100000)
+        try:
+            # Run synthesis sync
+            stories, index = synthesize_stories_sync(
+                commits=repo_commits,
+                sessions=repo_sessions,
+                model=model,
+                batch_size=batch_size,
+                progress_callback=progress,
+            )
 
-        # Check if we exceed limits (only warn for cloud generation)
-        if cloud and len(commit_list) > max_commits:
-            num_batches = (len(commit_list) + max_commits - 1) // max_commits
-            console.print()
-            console.print(f"  ⚠ {len(commit_list)} commits exceeds {max_commits}-commit limit")
-            console.print()
-            console.print(f"  Will split into {num_batches} batches:")
-            for batch_num in range(num_batches):
-                start = batch_num * max_commits + 1
-                end = min((batch_num + 1) * max_commits, len(commit_list))
-                batch_commits = commit_list[batch_num * max_commits:end]
-                batch_tokens = estimate_tokens(batch_commits)
-                console.print(f"    Batch {batch_num + 1}: commits {start}-{end} (est. {batch_tokens // 1000}k tokens)")
-            console.print()
+            # Generate public/internal posts for each story
+            if stories and not dry_run:
+                from .story_synthesis import transform_story_for_feed_sync, _build_fallback_post
+
+                if not json_output:
+                    console.print(f"  Generating build log posts...")
+
+                for story in stories:
+                    try:
+                        # Generate Tripartite Codex content (internal includes all fields)
+                        result = transform_story_for_feed_sync(story, mode="internal")
+
+                        # Store structured fields
+                        story.hook = result.hook
+                        story.what = result.what
+                        story.value = result.value
+                        story.insight = result.insight
+                        story.show = result.show
+                        story.post_body = result.post_body
+
+                        # Internal-specific fields
+                        if hasattr(result, 'problem') and result.problem:
+                            story.problem = result.problem
+                        if hasattr(result, 'how') and result.how:
+                            story.implementation_details = result.how
+
+                        # Legacy fields for backward compatibility
+                        what_clean = result.what.rstrip(".").rstrip()
+                        value_clean = result.value.lstrip(".").lstrip()
+                        story.public_post = f"{result.hook}\n\n{what_clean}. {value_clean}\n\nInsight: {result.insight}"
+                        story.internal_post = story.public_post
+                        story.public_show = result.show
+                        story.internal_show = result.show
+                    except Exception as e:
+                        # Fallback: build from story data
+                        from .story_synthesis import _build_fallback_codex
+                        result = _build_fallback_codex(story, "internal")
+                        story.hook = result.hook
+                        story.what = result.what
+                        story.value = result.value
+                        story.insight = result.insight
+                        story.post_body = result.post_body
+                        what_clean = result.what.rstrip(".").rstrip()
+                        value_clean = result.value.lstrip(".").lstrip()
+                        story.public_post = f"{result.hook}\n\n{what_clean}. {value_clean}\n\nInsight: {result.insight}"
+                        story.internal_post = story.public_post
+
+            # Save to SQLite
+            if not dry_run and stories:
+                db = get_db()
+                project_id = db.register_project(repo_path, repo_path.name)
+
+                for story in stories:
+                    db.save_story(story, project_id)
+
+                # Update freshness with latest commit
+                if repo_commits:
+                    latest_commit = repo_commits[0]  # Already sorted by date desc
+                    db.update_freshness(
+                        project_id,
+                        latest_commit.sha,
+                        latest_commit.timestamp,
+                    )
+
+                if not json_output:
+                    print_success(f"Saved {len(stories)} stories to SQLite")
+            else:
+                 if not json_output:
+                     print_info("Dry run - not saved")
 
-            if not confirm("Continue with generation?"):
-                console.print(f"  [{BRAND_MUTED}]Skipped {repo_info.name}[/]")
-                continue
+            all_generated_stories.extend(stories)
 
-        # Calculate number of batches for progress
-        num_batches = (len(commit_list) + batch_size - 1) // batch_size
-        
-        # Generate stories with progress tracking
-        if not json_output and num_batches > 1:
-            # Use progress bar for multiple batches
-            with BatchProgress(num_batches, f"Analyzing {repo_info.name}") as progress:
-                def on_progress(batch_num, total, status):
-                    if status == "complete":
-                        progress.update(1, f"batch {batch_num}/{total}")
-                
-                stories = _generate_stories(
-                    commits=commit_list,
-                    repo_info=repo_info,
-                    batch_size=batch_size,
-                    local=local,
-                    template=template,
-                    custom_prompt=prompt,
-                    progress_callback=on_progress,
-                )
-        else:
-            # Single batch or JSON mode - no progress bar needed
-            if not json_output and num_batches == 1:
-                console.print(f"  Analyzing {len(commit_list)} commits...")
-            
-            stories = _generate_stories(
-                commits=commit_list,
-                repo_info=repo_info,
-                batch_size=batch_size,
-                local=local,
-                template=template,
-                custom_prompt=prompt,
-            )
-        
-        for story in stories:
+        except Exception as e:
             if not json_output:
-                console.print(f"  • {story['summary']}")
-            total_stories += 1
-            all_stories.append(story)
-        
-        # Log cloud operation if using cloud
-        if cloud and stories:
-            log_cloud_operation(
-                operation="cloud_generation",
-                destination="repr.dev",
-                payload_summary={
-                    "repo": repo_info.name,
-                    "commits": len(commit_list),
-                    "stories_generated": len(stories),
-                },
-                bytes_sent=len(str(commit_list)) // 2,  # Rough estimate
-            )
-        
-        if not json_output:
-            console.print()
-    
+                print_error(f"Failed to generate for {repo_path.name}: {e}")
+
     if json_output:
-        print(json.dumps({"generated": total_stories, "stories": all_stories}, indent=2, default=str))
-        return
-    
-    if dry_run:
-        console.print()
-        console.print("Continue with generation? (run without --dry-run)")
-    else:
-        print_success(f"Generated {total_stories} stories")
+        print(json.dumps({
+            "success": True, 
+            "stories_count": len(all_generated_stories),
+            "stories": [s.model_dump(mode="json") for s in all_generated_stories]
+        }, default=str)) 
+    elif all_generated_stories:
         console.print()
-        console.print(f"Stories saved to: {STORIES_DIR}")
-        print_next_steps([
-            "repr stories            View your stories",
-            "repr push               Publish to repr.dev (requires login)",
-        ])
+        print_success(f"Generated {len(all_generated_stories)} stories")
+        print_info("Run `repr dashboard` to view")
 
 
 async def _generate_stories_async(
@@ -748,6 +1279,15 @@ async def _generate_stories_async(
                     if not content or content.startswith("[Batch"):
                         continue
 
+                    # Get technologies from LLM output, fallback to file-based detection
+                    technologies = story_output.technologies or []
+                    if not technologies:
+                        # Detect from files in this batch
+                        all_files = []
+                        for c in batch:
+                            all_files.extend(c.get("files", []))
+                        technologies = _detect_technologies_from_files(all_files)
+
                     metadata = {
                         "summary": summary,
                         "repo_name": repo_info.name,
@@ -761,6 +1301,8 @@ async def _generate_stories_async(
                         "generated_locally": local,
                         "template": template,
                         "needs_review": False,
+                        # Technologies
+                        "technologies": technologies,
                         # Categories
                         "category": story_output.category,
                         "scope": story_output.scope,
@@ -815,49 +1357,286 @@ def _generate_stories(
 # STORIES MANAGEMENT
 # =============================================================================
 
-@app.command()
-def stories(
-    repo: Optional[str] = typer.Option(None, "--repo", help="Filter by repository"),
-    category: Optional[str] = typer.Option(None, "--category", "-c", help="Filter by category (feature, bugfix, refactor, perf, infra, docs, test, chore)"),
-    scope: Optional[str] = typer.Option(None, "--scope", "-s", help="Filter by scope (user-facing, internal, platform, ops)"),
-    stack: Optional[str] = typer.Option(None, "--stack", help="Filter by stack (frontend, backend, database, infra, mobile, fullstack)"),
-    needs_review: bool = typer.Option(False, "--needs-review", help="Show only stories needing review"),
+@app.command("week")
+def week(
     json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
 ):
     """
-    List all stories.
+    Weekly summary — what you built in the last 7 days.
     
-    Example:
-        repr stories
-        repr stories --repo myproject
-        repr stories --category feature
-        repr stories --scope user-facing
-        repr stories --stack backend
-        repr stories --needs-review
+    Provides a quick overview of your work from the past week,
+    including commits and generated stories.
     """
-    story_list = list_stories(repo_name=repo, needs_review=needs_review)
+    from .timeline import extract_commits_from_git
+    from .db import get_db
     
-    # Apply category filters (local filtering since storage doesn't support these yet)
-    if category:
-        story_list = [s for s in story_list if s.get("category") == category]
-    if scope:
-        story_list = [s for s in story_list if s.get("scope") == scope]
-    if stack:
-        story_list = [s for s in story_list if s.get("stack") == stack]
+    week_ago = datetime.now() - timedelta(days=7)
+    
+    # Get stories from DB
+    db = get_db()
+    story_list = list_stories()
+    recent_stories = []
+    for s in story_list:
+        try:
+            created_at = s.get("created_at")
+            if isinstance(created_at, str):
+                dt = datetime.fromisoformat(created_at.replace("Z", "+00:00")).replace(tzinfo=None)
+            else:
+                dt = created_at.replace(tzinfo=None)
+            
+            if dt > week_ago:
+                recent_stories.append(s)
+        except Exception:
+            continue
+    
+    # Get commits from tracked repos
+    tracked = get_tracked_repos()
+    all_commits = []
+    for repo in tracked:
+        path = Path(repo["path"])
+        if path.exists():
+            repo_commits = extract_commits_from_git(path, days=7)
+            for c in repo_commits:
+                c_dict = {
+                    "sha": c.sha,
+                    "message": c.message,
+                    "date": c.timestamp.isoformat(),
+                    "repo_name": path.name,
+                    "insertions": c.insertions,
+                    "deletions": c.deletions,
+                }
+                all_commits.append(c_dict)
     
     if json_output:
-        print(json.dumps(story_list, indent=2, default=str))
+        print(json.dumps({
+            "stories": recent_stories,
+            "commits": all_commits,
+            "period": "7 days",
+        }, indent=2, default=str))
         return
+
+    print_header()
+    console.print(f"[bold]Weekly Summary[/] (since {week_ago.strftime('%Y-%m-%d')})")
+    console.print()
     
-    if not story_list:
-        print_info("No stories found.")
-        print_info("Run `repr generate` to create stories from your commits.")
-        raise typer.Exit()
+    # Stats
+    total_commits = len(all_commits)
+    repos = set(c.get("repo_name") for c in all_commits)
+    total_adds = sum(c.get("insertions", 0) for c in all_commits)
+    total_dels = sum(c.get("deletions", 0) for c in all_commits)
     
-    console.print(f"[bold]Stories[/] ({len(story_list)} total)")
+    console.print(f"  {total_commits} commits across {len(repos)} repos")
+    console.print(f"  [{BRAND_SUCCESS}]+{total_adds}[/] / [{BRAND_ERROR}]-{total_dels}[/] lines changed")
     console.print()
-
-    # Group stories by repository
+    
+    # Recent stories
+    if recent_stories:
+        console.print("[bold]Stories Generated[/]")
+        for s in recent_stories[:10]:
+            summary = s.get("summary", s.get("title", "Untitled"))
+            repo = s.get("repo_name", "unknown")
+            console.print(f"  • {summary} [{BRAND_MUTED}]({repo})[/]")
+        console.print()
+    
+    # Commits by repo
+    console.print("[bold]Recent Activity[/]")
+    by_repo = defaultdict(list)
+    for c in all_commits:
+        by_repo[c["repo_name"]].append(c)
+    
+    for repo_name, repo_commits in sorted(by_repo.items(), key=lambda x: -len(x[1])):
+        console.print(f"  [bold]{repo_name}[/] ({len(repo_commits)} commits)")
+        for c in repo_commits[:3]:
+            msg = c["message"].split("\n")[0][:60]
+            console.print(f"    - {msg}")
+        if len(repo_commits) > 3:
+            console.print(f"    [{BRAND_MUTED}]... and {len(repo_commits) - 3} more[/]")
+    
+    console.print()
+    print_info("Run `repr generate` to turn recent commits into stories.")
+
+
+@app.command("standup")
+def standup(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """
+    Quick standup — what you did yesterday and today.
+    """
+    from .timeline import extract_commits_from_git
+    
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    yesterday = today - timedelta(days=1)
+    
+    tracked = get_tracked_repos()
+    all_commits = []
+    for repo in tracked:
+        path = Path(repo["path"])
+        if path.exists():
+            repo_commits = extract_commits_from_git(path, days=2)
+            for c in repo_commits:
+                c_dict = {
+                    "sha": c.sha,
+                    "message": c.message,
+                    "date": c.timestamp.isoformat(),
+                    "repo_name": path.name,
+                }
+                all_commits.append(c_dict)
+    
+    today_commits = []
+    yesterday_commits = []
+    
+    for c in all_commits:
+        try:
+            commit_date = datetime.fromisoformat(c["date"].replace("Z", "+00:00")).replace(tzinfo=None)
+            if commit_date >= today:
+                today_commits.append(c)
+            elif commit_date >= yesterday:
+                yesterday_commits.append(c)
+        except (ValueError, TypeError):
+            yesterday_commits.append(c)
+            
+    if json_output:
+        print(json.dumps({
+            "today": today_commits,
+            "yesterday": yesterday_commits,
+        }, indent=2, default=str))
+        return
+
+    print_header()
+    console.print("[bold]Standup Summary[/]")
+    console.print()
+    
+    if yesterday_commits:
+        console.print("[bold]Yesterday[/]")
+        for c in yesterday_commits:
+            msg = c["message"].split("\n")[0][:70]
+            console.print(f"  • {msg} [{BRAND_MUTED}]({c['repo_name']})[/]")
+        console.print()
+    
+    if today_commits:
+        console.print("[bold]Today[/]")
+        for c in today_commits:
+            msg = c["message"].split("\n")[0][:70]
+            console.print(f"  • {msg} [{BRAND_MUTED}]({c['repo_name']})[/]")
+        console.print()
+    
+    if not yesterday_commits and not today_commits:
+        print_info("No activity found in the last 2 days.")
+    else:
+        print_info("Generated from local git history.")
+
+
+@app.command("since")
+def since(
+    date_ref: str = typer.Argument(..., help="Date reference (e.g., 'monday', '2024-01-01', '3 days ago')"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """
+    Reflection summary since a specific date.
+    """
+    from .timeline import extract_commits_from_git
+    
+    parsed_date_str = _parse_date_reference(date_ref)
+    if not parsed_date_str:
+        print_error(f"Could not parse date: {date_ref}")
+        print_info("Try: 'monday', 'yesterday', '2024-01-01', '3 days ago'")
+        raise typer.Exit(1)
+        
+    since_date = datetime.fromisoformat(parsed_date_str)
+    now = datetime.now()
+    days_back = (now - since_date).days + 1
+    
+    tracked = get_tracked_repos()
+    all_commits = []
+    for repo in tracked:
+        path = Path(repo["path"])
+        if path.exists():
+            repo_commits = extract_commits_from_git(path, days=days_back)
+            for c in repo_commits:
+                if c.timestamp.replace(tzinfo=None) >= since_date:
+                    c_dict = {
+                        "sha": c.sha,
+                        "message": c.message,
+                        "date": c.timestamp.isoformat(),
+                        "repo_name": path.name,
+                    }
+                    all_commits.append(c_dict)
+                    
+    if json_output:
+        print(json.dumps({
+            "since": parsed_date_str,
+            "commits": all_commits,
+        }, indent=2, default=str))
+        return
+
+    print_header()
+    console.print(f"[bold]Work since {date_ref}[/] ({since_date.strftime('%Y-%m-%d')})")
+    console.print()
+    
+    if not all_commits:
+        print_info(f"No commits found since {date_ref}.")
+        return
+        
+    by_repo = defaultdict(list)
+    for c in all_commits:
+        by_repo[c["repo_name"]].append(c)
+        
+    for repo_name, repo_commits in sorted(by_repo.items(), key=lambda x: -len(x[1])):
+        console.print(f"  [bold]{repo_name}[/] ({len(repo_commits)} commits)")
+        for c in repo_commits[:5]:
+            msg = c["message"].split("\n")[0][:60]
+            console.print(f"    - {msg}")
+        if len(repo_commits) > 5:
+            console.print(f"    [{BRAND_MUTED}]... and {len(repo_commits) - 5} more[/]")
+            
+    console.print()
+    print_info(f"Summary based on {len(all_commits)} commits.")
+
+
+@app.command()
+def stories(
+    repo: Optional[str] = typer.Option(None, "--repo", help="Filter by repository"),
+    category: Optional[str] = typer.Option(None, "--category", "-c", help="Filter by category (feature, bugfix, refactor, perf, infra, docs, test, chore)"),
+    scope: Optional[str] = typer.Option(None, "--scope", "-s", help="Filter by scope (user-facing, internal, platform, ops)"),
+    stack: Optional[str] = typer.Option(None, "--stack", help="Filter by stack (frontend, backend, database, infra, mobile, fullstack)"),
+    needs_review: bool = typer.Option(False, "--needs-review", help="Show only stories needing review"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """
+    List all stories.
+    
+    Example:
+        repr stories
+        repr stories --repo myproject
+        repr stories --category feature
+        repr stories --scope user-facing
+        repr stories --stack backend
+        repr stories --needs-review
+    """
+    story_list = list_stories(repo_name=repo, needs_review=needs_review)
+    
+    # Apply category filters (local filtering since storage doesn't support these yet)
+    if category:
+        story_list = [s for s in story_list if s.get("category") == category]
+    if scope:
+        story_list = [s for s in story_list if s.get("scope") == scope]
+    if stack:
+        story_list = [s for s in story_list if s.get("stack") == stack]
+    
+    if json_output:
+        print(json.dumps(story_list, indent=2, default=str))
+        return
+    
+    if not story_list:
+        print_info("No stories found.")
+        print_info("Run `repr generate` to create stories from your commits.")
+        raise typer.Exit()
+    
+    console.print(f"[bold]Stories[/] ({len(story_list)} total)")
+    console.print()
+
+    # Group stories by repository
     by_repo = defaultdict(list)
     for story in story_list[:20]:
         r_name = story.get("repo_name", "unknown")
@@ -1100,93 +1879,106 @@ def stories_review():
 
 @app.command()
 def push(
-    story_id: Optional[str] = typer.Option(None, "--story", help="Push specific story"),
-    all_stories: bool = typer.Option(False, "--all", help="Push all unpushed stories"),
+    visibility: str = typer.Option("friends", "--visibility", help="Visibility setting: public, friends, private"),
+    force: bool = typer.Option(False, "--force", help="Re-push all stories, even if already pushed"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Preview what would be pushed"),
 ):
     """
-    Publish stories to repr.dev.
-    
+    Sync local stories to repr.dev backend.
+
     Examples:
         repr push
-        repr push --story 01ARYZ6S41TSV4RRFFQ69G5FAV
+        repr push --visibility public
+        repr push --force
     """
     from .privacy import check_cloud_permission, log_cloud_operation
-    
+    from .api import push_stories_batch, APIError, AuthError
+    from .db import get_db
+
+    # Check authentication
+    if not get_access_token():
+        print_error("Not authenticated")
+        print_info("Run 'repr login' to authenticate")
+        raise typer.Exit(1)
+
     allowed, reason = check_cloud_permission("push")
     if not allowed:
         print_error("Publishing blocked")
         print_info(reason)
         raise typer.Exit(1)
-    
-    # Get stories to push
-    if story_id:
-        result = load_story(story_id)
-        if not result:
-            print_error(f"Story not found: {story_id}")
-            raise typer.Exit(1)
-        content, metadata = result
-        to_push = [{"id": story_id, "content": content, **metadata}]
-    else:
-        to_push = get_unpushed_stories()
-    
-    if not to_push:
-        print_success("All stories already synced!")
+
+    # Get all stories from database
+    db = get_db()
+    all_stories = db.list_stories(limit=10000)
+
+    if not all_stories:
+        print_info("No stories to push")
         raise typer.Exit()
-    
-    console.print(f"Publishing {len(to_push)} story(ies) to repr.dev...")
+
+    console.print(f"Found {len(all_stories)} story(ies) in local database")
     console.print()
-    
+
     if dry_run:
-        for s in to_push:
-            console.print(f"  • {s.get('summary', s.get('id'))}")
+        for story in all_stories:
+            console.print(f"  • {story.title[:60]}")
         console.print()
-        console.print("Run without --dry-run to publish")
+        console.print("Run without --dry-run to push")
         raise typer.Exit()
-    
+
     # Build batch payload
-    from .api import push_stories_batch
-    
+    console.print(f"Preparing to push with visibility: {visibility}...")
+
     stories_payload = []
-    for s in to_push:
-        content, meta = load_story(s["id"])
-        # Use local story ID as client_id for sync
-        payload = {**meta, "content": content, "client_id": s["id"]}
+    for story in all_stories:
+        # Convert Story model to dict and ensure author_name is included
+        payload = story.model_dump(mode="json")
+        payload["visibility"] = visibility
+        payload["client_id"] = story.id  # Use story ID for sync tracking
         stories_payload.append(payload)
-    
-    # Push all stories in a single batch request
-    try:
-        result = asyncio.run(push_stories_batch(stories_payload))
-        pushed = result.get("pushed", 0)
-        results = result.get("results", [])
-        
-        # Mark successful stories as pushed and display results
-        for i, story_result in enumerate(results):
-            story_id_local = to_push[i]["id"]
-            summary = to_push[i].get("summary", story_id_local)[:50]
-            
-            if story_result.get("success"):
-                mark_story_pushed(story_id_local)
-                console.print(f"  [{BRAND_SUCCESS}]✓[/] {summary}")
-            else:
-                error_msg = story_result.get("error", "Unknown error")
-                console.print(f"  [{BRAND_ERROR}]✗[/] {summary}: {error_msg}")
-        
-    except (APIError, AuthError) as e:
-        print_error(f"Batch push failed: {e}")
-        raise typer.Exit(1)
-    
+
+    # Push all stories in batch with progress
+    console.print(f"Pushing {len(stories_payload)} stories...")
+    console.print()
+
+    with BatchProgress() as progress:
+        try:
+            result = asyncio.run(push_stories_batch(stories_payload))
+            pushed = result.get("pushed", 0)
+            failed = result.get("failed", 0)
+            results = result.get("results", [])
+
+            # Display results
+            for i, story_result in enumerate(results):
+                story_title = all_stories[i].title[:50] if i < len(all_stories) else "Unknown"
+
+                if story_result.get("success"):
+                    console.print(f"  [{BRAND_SUCCESS}]✓[/] {story_title}")
+                else:
+                    error_msg = story_result.get("error", "Unknown error")
+                    console.print(f"  [{BRAND_ERROR}]✗[/] {story_title}: {error_msg}")
+
+        except (APIError, AuthError) as e:
+            print_error(f"Batch push failed: {e}")
+            raise typer.Exit(1)
+
     # Log operation
     if pushed > 0:
         log_cloud_operation(
             operation="push",
             destination="repr.dev",
-            payload_summary={"stories_pushed": pushed},
+            payload_summary={
+                "stories_pushed": pushed,
+                "visibility": visibility,
+                "force": force,
+            },
             bytes_sent=0,
         )
-    
+
     console.print()
-    print_success(f"Pushed {pushed}/{len(to_push)} stories")
+    if failed > 0:
+        print_warning(f"Pushed {pushed}/{len(stories_payload)} stories ({failed} failed)")
+    else:
+        print_success(f"Pushed {pushed}/{len(stories_payload)} stories")
 
 
 @app.command()
@@ -1733,6 +2525,138 @@ def hooks_queue(
         pass
 
 
+# =============================================================================
+# CRON SCHEDULING
+# =============================================================================
+
+@cron_app.command("install")
+def cron_install(
+    interval: int = typer.Option(4, "--interval", "-i", help="Hours between runs (default: 4)"),
+    min_commits: int = typer.Option(3, "--min-commits", "-m", help="Minimum commits to trigger generation"),
+):
+    """
+    Install cron job for automatic story generation.
+
+    Runs every 4 hours by default, only generating if there are
+    enough commits in the queue.
+
+    Example:
+        repr cron install
+        repr cron install --interval 6 --min-commits 5
+    """
+    from .cron import install_cron
+
+    result = install_cron(interval, min_commits)
+
+    if result["success"]:
+        if result["already_installed"]:
+            print_success(result["message"])
+        else:
+            print_success(result["message"])
+            console.print()
+            console.print(f"[{BRAND_MUTED}]Stories will generate every {interval}h when queue has ≥{min_commits} commits[/]")
+            console.print(f"[{BRAND_MUTED}]Logs: ~/.repr/logs/cron.log[/]")
+    else:
+        print_error(result["message"])
+        raise typer.Exit(1)
+
+
+@cron_app.command("remove")
+def cron_remove():
+    """
+    Remove cron job for story generation.
+
+    Example:
+        repr cron remove
+    """
+    from .cron import remove_cron
+
+    result = remove_cron()
+
+    if result["success"]:
+        print_success(result["message"])
+    else:
+        print_error(result["message"])
+        raise typer.Exit(1)
+
+
+@cron_app.command("pause")
+def cron_pause():
+    """
+    Pause cron job without removing it.
+
+    Example:
+        repr cron pause
+    """
+    from .cron import pause_cron
+
+    result = pause_cron()
+
+    if result["success"]:
+        print_success(result["message"])
+        console.print(f"[{BRAND_MUTED}]Use `repr cron resume` to re-enable[/]")
+    else:
+        print_error(result["message"])
+        raise typer.Exit(1)
+
+
+@cron_app.command("resume")
+def cron_resume():
+    """
+    Resume paused cron job.
+
+    Example:
+        repr cron resume
+    """
+    from .cron import resume_cron
+
+    result = resume_cron()
+
+    if result["success"]:
+        print_success(result["message"])
+    else:
+        print_error(result["message"])
+        raise typer.Exit(1)
+
+
+@cron_app.command("status")
+def cron_status(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """
+    Show cron job status.
+
+    Example:
+        repr cron status
+    """
+    from .cron import get_cron_status
+
+    status = get_cron_status()
+
+    if json_output:
+        print(json.dumps(status, indent=2))
+        return
+
+    console.print("[bold]Cron Status[/]")
+    console.print()
+
+    if not status["installed"]:
+        console.print(f"[{BRAND_MUTED}]○[/] Not installed")
+        console.print()
+        console.print(f"[{BRAND_MUTED}]Run `repr cron install` to enable scheduled generation[/]")
+        return
+
+    if status["paused"]:
+        console.print(f"[{BRAND_WARNING}]⏸[/] Paused")
+        console.print(f"  [{BRAND_MUTED}]Interval: every {status['interval_hours']}h[/]")
+        console.print()
+        console.print(f"[{BRAND_MUTED}]Run `repr cron resume` to re-enable[/]")
+    else:
+        console.print(f"[{BRAND_SUCCESS}]✓[/] Active")
+        console.print(f"  [{BRAND_MUTED}]Interval: every {status['interval_hours']}h[/]")
+        console.print(f"  [{BRAND_MUTED}]Logs: ~/.repr/logs/cron.log[/]")
+
+
 # =============================================================================
 # LLM CONFIGURATION
 # =============================================================================
@@ -1743,7 +2667,7 @@ def llm_add(
 ):
     """
     Configure a BYOK provider.
-    
+
     Example:
         repr llm add openai
     """
@@ -1948,6 +2872,77 @@ def llm_test():
             console.print(f"  [{BRAND_SUCCESS}]✓[/] {provider}")
 
 
+# =============================================================================
+# CONFIGURE (unified setup wizard)
+# =============================================================================
+
+@configure_app.callback(invoke_without_command=True)
+def configure_main(ctx: typer.Context):
+    """
+    Configure repr settings (LLM, repos, schedule).
+
+    Run without arguments to see an interactive menu.
+    Use subcommands for direct configuration:
+
+        repr configure llm       Configure LLM provider
+        repr configure repos     Configure tracked repositories
+        repr configure schedule  Configure automatic generation
+
+    Example:
+        repr configure
+    """
+    if ctx.invoked_subcommand is None:
+        from .configure import run_configure_menu
+        run_configure_menu()
+
+
+@configure_app.command("llm")
+def configure_llm():
+    """
+    Configure LLM provider interactively.
+
+    Supports:
+    - Local: Ollama, LM Studio
+    - API: OpenAI, Anthropic, Gemini, Groq, Together, OpenRouter
+
+    Example:
+        repr configure llm
+    """
+    from .configure import wizard_llm
+    wizard_llm()
+
+
+@configure_app.command("repos")
+def configure_repos():
+    """
+    Configure tracked repositories.
+
+    Scans for git repositories and lets you select which to track.
+
+    Example:
+        repr configure repos
+    """
+    from .configure import wizard_repos
+    wizard_repos()
+
+
+@configure_app.command("schedule")
+def configure_schedule():
+    """
+    Configure automatic story generation schedule.
+
+    Options:
+    - Scheduled (cron) - Every N hours
+    - On commit (hooks) - After N commits
+    - Manual - Run `repr generate` yourself
+
+    Example:
+        repr configure schedule
+    """
+    from .configure import wizard_schedule
+    wizard_schedule()
+
+
 # =============================================================================
 # PRIVACY
 # =============================================================================
@@ -2340,12 +3335,12 @@ def data_restore(
 def data_clear_cache():
     """
     Clear local cache.
-    
+
     Example:
         repr data clear-cache
     """
     from .config import clear_cache, get_cache_size
-    
+
     size = get_cache_size()
     clear_cache()
     print_success(f"Cache cleared ({format_bytes(size)} freed)")
@@ -2353,7 +3348,200 @@ def data_clear_cache():
     console.print("  Config preserved")
 
 
-# =============================================================================
+@data_app.command("migrate-db")
+def data_migrate_db(
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be migrated"),
+    project: Optional[Path] = typer.Option(None, "--project", "-p", help="Migrate specific project"),
+):
+    """
+    Migrate store.json files to central SQLite database.
+
+    This command imports existing .repr/store.json files into the central
+    SQLite database at ~/.repr/stories.db for faster queries.
+
+    Example:
+        repr data migrate-db              # Migrate all tracked repos
+        repr data migrate-db --dry-run    # Preview migration
+        repr data migrate-db -p /path/to/repo
+    """
+    from .storage import migrate_stores_to_db, get_db_stats
+
+    project_paths = [project] if project else None
+
+    with create_spinner("Migrating stories to SQLite...") as progress:
+        task = progress.add_task("migrating", total=None)
+
+        if dry_run:
+            console.print("[bold]Dry run mode - no changes will be made[/]\n")
+
+        stats = migrate_stores_to_db(project_paths=project_paths, dry_run=dry_run)
+
+        progress.update(task, completed=True)
+
+    console.print()
+    console.print(f"Projects scanned: {stats['projects_scanned']}")
+    console.print(f"Projects migrated: {stats['projects_migrated']}")
+    console.print(f"Stories imported: {stats['stories_imported']}")
+
+    if stats['errors']:
+        console.print()
+        print_warning(f"{len(stats['errors'])} errors:")
+        for error in stats['errors'][:5]:
+            console.print(f"  • {error}")
+        if len(stats['errors']) > 5:
+            console.print(f"  ... and {len(stats['errors']) - 5} more")
+
+    if not dry_run and stats['stories_imported'] > 0:
+        console.print()
+        db_stats = get_db_stats()
+        console.print(f"Database: {db_stats['db_path']}")
+        console.print(f"Total stories: {db_stats['story_count']}")
+        console.print(f"Database size: {format_bytes(db_stats['db_size_bytes'])}")
+
+
+@data_app.command("db-stats")
+def data_db_stats():
+    """
+    Show SQLite database statistics.
+
+    Example:
+        repr data db-stats
+    """
+    from .storage import get_db_stats
+    from .db import get_db_path
+
+    if not get_db_path().exists():
+        print_info("No SQLite database yet.")
+        print_info("Run `repr data migrate-db` to create one.")
+        return
+
+    stats = get_db_stats()
+
+    console.print("[bold]SQLite Database Stats[/]")
+    console.print()
+    console.print(f"Path: {stats['db_path']}")
+    console.print(f"Size: {format_bytes(stats['db_size_bytes'])}")
+    console.print()
+    console.print(f"Stories: {stats['story_count']}")
+    console.print(f"Projects: {stats['project_count']}")
+    console.print(f"Unique files: {stats['unique_files']}")
+    console.print(f"Unique commits: {stats['unique_commits']}")
+
+    if stats['categories']:
+        console.print()
+        console.print("[bold]By Category:[/]")
+        for cat, count in sorted(stats['categories'].items(), key=lambda x: -x[1]):
+            console.print(f"  {cat}: {count}")
+
+
+@data_app.command("clear")
+def data_clear(
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """
+    Clear all stories from database and storage.
+
+    This permanently deletes:
+    - All stories from the SQLite database
+    - All story files from ~/.repr/stories/
+    - Local cache
+
+    Projects registry and config are preserved.
+
+    Example:
+        repr data clear           # With confirmation
+        repr data clear --force   # Skip confirmation
+    """
+    from .db import get_db_path
+    from .storage import STORIES_DIR
+    from .config import get_cache_size, clear_cache
+    import shutil
+
+    db_path = get_db_path()
+
+    # Check what exists
+    db_exists = db_path.exists()
+    stories_dir_exists = STORIES_DIR.exists()
+    cache_size = get_cache_size()
+
+    if not db_exists and not stories_dir_exists and cache_size == 0:
+        print_info("Nothing to clear - no database, stories, or cache found.")
+        return
+
+    # Count what we're about to delete
+    story_count = 0
+    db_size = 0
+    stories_file_count = 0
+
+    if db_exists:
+        from .storage import get_db_stats
+        try:
+            stats = get_db_stats()
+            story_count = stats.get('story_count', 0)
+            db_size = stats.get('db_size_bytes', 0)
+        except Exception:
+            db_size = db_path.stat().st_size if db_path.exists() else 0
+
+    if stories_dir_exists:
+        stories_file_count = len(list(STORIES_DIR.glob("*")))
+
+    # Show what will be deleted
+    console.print("[bold red]This will permanently delete:[/]")
+    console.print()
+    if db_exists:
+        console.print(f"  • Database: {db_path}")
+        console.print(f"    {story_count} stories, {format_bytes(db_size)}")
+    if stories_dir_exists and stories_file_count > 0:
+        console.print(f"  • Story files: {STORIES_DIR}")
+        console.print(f"    {stories_file_count} files")
+    if cache_size > 0:
+        console.print(f"  • Cache: {format_bytes(cache_size)}")
+    console.print()
+    console.print("[dim]Projects registry and config will be preserved.[/]")
+    console.print()
+
+    if not force:
+        if not confirm("Are you sure you want to delete all stories and cache?"):
+            print_info("Cancelled")
+            raise typer.Exit()
+
+    # Delete database
+    if db_exists:
+        try:
+            # Also delete WAL and SHM files if they exist
+            db_path.unlink()
+            wal_path = db_path.with_suffix(".db-wal")
+            shm_path = db_path.with_suffix(".db-shm")
+            if wal_path.exists():
+                wal_path.unlink()
+            if shm_path.exists():
+                shm_path.unlink()
+        except Exception as e:
+            print_error(f"Failed to delete database: {e}")
+            raise typer.Exit(1)
+
+    # Delete stories directory contents (but keep the directory)
+    if stories_dir_exists:
+        try:
+            shutil.rmtree(STORIES_DIR)
+            STORIES_DIR.mkdir(exist_ok=True)
+        except Exception as e:
+            print_error(f"Failed to clear stories directory: {e}")
+            raise typer.Exit(1)
+
+    # Clear cache
+    clear_cache()
+
+    print_success("All stories and cache cleared")
+    if db_exists:
+        console.print(f"  Deleted: {story_count} stories from database")
+    if stories_file_count > 0:
+        console.print(f"  Deleted: {stories_file_count} story files")
+    if cache_size > 0:
+        console.print(f"  Cleared: {format_bytes(cache_size)} from cache")
+
+
+# =============================================================================
 # PROFILE
 # =============================================================================
 
@@ -2535,6 +3723,254 @@ def profile_link():
         print_info("Run `repr profile set-username <name>`")
 
 
+# =============================================================================
+# PUBLISH/UNPUBLISH COMMANDS
+# =============================================================================
+
+@app.command("publish")
+def publish_story(
+    story_id: str = typer.Argument(..., help="Story ID to publish"),
+    visibility: str = typer.Option("public", "--visibility", "-v", help="Visibility: public, friends, private"),
+):
+    """
+    Set story visibility.
+
+    Examples:
+        repr publish abc123
+        repr publish abc123 --visibility friends
+    """
+    from .api import set_story_visibility, AuthError
+
+    if visibility not in ("public", "friends", "private"):
+        print_error(f"Invalid visibility: {visibility}")
+        print_info("Valid options: public, friends, private")
+        raise typer.Exit(1)
+
+    if not is_authenticated():
+        print_error("Not authenticated")
+        print_info("Run `repr login` first")
+        raise typer.Exit(1)
+
+    try:
+        with create_spinner(f"Setting visibility to {visibility}..."):
+            result = asyncio.run(set_story_visibility(story_id, visibility))
+        print_success(f"Story visibility set to {visibility}")
+    except AuthError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(f"API error: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("unpublish")
+def unpublish_story(
+    story_id: str = typer.Argument(..., help="Story ID to unpublish"),
+):
+    """
+    Set story to private.
+
+    Examples:
+        repr unpublish abc123
+    """
+    from .api import set_story_visibility, AuthError
+
+    if not is_authenticated():
+        print_error("Not authenticated")
+        print_info("Run `repr login` first")
+        raise typer.Exit(1)
+
+    try:
+        with create_spinner("Setting story to private..."):
+            result = asyncio.run(set_story_visibility(story_id, "private"))
+        print_success("Story set to private")
+    except AuthError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(f"API error: {e}")
+        raise typer.Exit(1)
+
+
+# =============================================================================
+# FRIENDS
+# =============================================================================
+
+@friends_app.command("add")
+def friends_add(
+    username: str = typer.Argument(..., help="Username to send friend request to"),
+):
+    """Send friend request.
+
+    Example:
+        repr friends add johndoe
+    """
+    if not is_authenticated():
+        print_error("Friend requests require sign-in")
+        print_info("Run `repr login` first")
+        raise typer.Exit(1)
+
+    from .api import send_friend_request, AuthError
+
+    try:
+        result = asyncio.run(send_friend_request(username))
+        print_success(f"Friend request sent to {username}")
+    except AuthError as e:
+        print_error(str(e))
+        print_info("Run `repr login` to re-authenticate")
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@friends_app.command("list")
+def friends_list():
+    """List friends.
+
+    Example:
+        repr friends list
+    """
+    if not is_authenticated():
+        print_error("Friends list requires sign-in")
+        print_info("Run `repr login` first")
+        raise typer.Exit(1)
+
+    from .api import get_friends, AuthError
+
+    try:
+        friends = asyncio.run(get_friends())
+
+        if not friends:
+            print_info("No friends yet")
+            return
+
+        table = create_table("Friends", ["Username", "Added"])
+        for friend in friends:
+            username = friend.get("username", "N/A")
+            added_at = friend.get("created_at", "")
+            # Format the date
+            if added_at:
+                from datetime import datetime
+                try:
+                    dt = datetime.fromisoformat(added_at.replace("Z", "+00:00"))
+                    added_at = dt.strftime("%Y-%m-%d")
+                except ValueError:
+                    pass
+            table.add_row(username, added_at or "N/A")
+        console.print(table)
+    except AuthError as e:
+        print_error(str(e))
+        print_info("Run `repr login` to re-authenticate")
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@friends_app.command("requests")
+def friends_requests():
+    """View pending friend requests.
+
+    Example:
+        repr friends requests
+    """
+    if not is_authenticated():
+        print_error("Friend requests require sign-in")
+        print_info("Run `repr login` first")
+        raise typer.Exit(1)
+
+    from .api import get_friend_requests, AuthError
+
+    try:
+        requests = asyncio.run(get_friend_requests())
+
+        if not requests:
+            print_info("No pending friend requests")
+            return
+
+        table = create_table("Pending Friend Requests", ["Request ID", "From", "Sent"])
+        for req in requests:
+            request_id = req.get("id", "N/A")
+            from_user = req.get("from_username", "N/A")
+            sent_at = req.get("created_at", "")
+            # Format the date
+            if sent_at:
+                from datetime import datetime
+                try:
+                    dt = datetime.fromisoformat(sent_at.replace("Z", "+00:00"))
+                    sent_at = dt.strftime("%Y-%m-%d")
+                except ValueError:
+                    pass
+            table.add_row(str(request_id), from_user, sent_at or "N/A")
+        console.print(table)
+
+        print_info("Use `repr friends approve <id>` or `repr friends reject <id>`")
+    except AuthError as e:
+        print_error(str(e))
+        print_info("Run `repr login` to re-authenticate")
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@friends_app.command("approve")
+def friends_approve(
+    request_id: str = typer.Argument(..., help="ID of the friend request to approve"),
+):
+    """Approve friend request.
+
+    Example:
+        repr friends approve abc123
+    """
+    if not is_authenticated():
+        print_error("Approving friend requests requires sign-in")
+        print_info("Run `repr login` first")
+        raise typer.Exit(1)
+
+    from .api import approve_friend_request, AuthError
+
+    try:
+        result = asyncio.run(approve_friend_request(request_id))
+        print_success("Friend request approved")
+    except AuthError as e:
+        print_error(str(e))
+        print_info("Run `repr login` to re-authenticate")
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
+@friends_app.command("reject")
+def friends_reject(
+    request_id: str = typer.Argument(..., help="ID of the friend request to reject"),
+):
+    """Reject friend request.
+
+    Example:
+        repr friends reject abc123
+    """
+    if not is_authenticated():
+        print_error("Rejecting friend requests requires sign-in")
+        print_info("Run `repr login` first")
+        raise typer.Exit(1)
+
+    from .api import reject_friend_request, AuthError
+
+    try:
+        result = asyncio.run(reject_friend_request(request_id))
+        print_info("Friend request rejected")
+    except AuthError as e:
+        print_error(str(e))
+        print_info("Run `repr login` to re-authenticate")
+        raise typer.Exit(1)
+    except APIError as e:
+        print_error(str(e))
+        raise typer.Exit(1)
+
+
 # =============================================================================
 # STATUS & INFO
 # =============================================================================
@@ -2590,6 +4026,184 @@ def status(
         print_info(f"Run `repr push` to publish {unpushed} stories")
 
 
+@app.command()
+def changes(
+    path: Optional[Path] = typer.Argument(
+        None,
+        help="Path to repository (default: current directory)",
+        exists=True,
+        resolve_path=True,
+    ),
+    explain: bool = typer.Option(False, "--explain", "-e", help="Use LLM to explain changes"),
+    compact: bool = typer.Option(False, "--compact", "-c", help="Compact output (no diff previews)"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """
+    Show file changes across git states with diff details.
+
+    Displays changes in three states:
+    - Unstaged: Tracked files modified but not staged (with diff preview)
+    - Staged: Changes ready to commit (with diff preview)
+    - Unpushed: Commits not yet pushed to remote
+
+    Example:
+        repr changes              # Show changes with diffs
+        repr changes --compact    # Just file names
+        repr changes --explain    # LLM summary
+        repr changes --json
+    """
+    from .change_synthesis import (
+        get_change_report,
+        ChangeState,
+        explain_group,
+    )
+
+    target_path = path or Path.cwd()
+    report = get_change_report(target_path)
+
+    if not report:
+        print_error(f"Not a git repository: {target_path}")
+        raise typer.Exit(1)
+
+    if json_output:
+        data = {
+            "repo_path": str(report.repo_path),
+            "timestamp": report.timestamp.isoformat(),
+            "unstaged": [
+                {
+                    "path": f.path,
+                    "change_type": f.change_type,
+                    "insertions": f.insertions,
+                    "deletions": f.deletions,
+                }
+                for f in report.unstaged
+            ],
+            "staged": [
+                {
+                    "path": f.path,
+                    "change_type": f.change_type,
+                    "insertions": f.insertions,
+                    "deletions": f.deletions,
+                }
+                for f in report.staged
+            ],
+            "unpushed": [
+                {
+                    "sha": c.sha,
+                    "message": c.message,
+                    "author": c.author,
+                    "timestamp": c.timestamp.isoformat(),
+                    "files": [{"path": f.path, "change_type": f.change_type} for f in c.files],
+                }
+                for c in report.unpushed
+            ],
+        }
+        if report.summary:
+            data["summary"] = {
+                "hook": report.summary.hook,
+                "what": report.summary.what,
+                "value": report.summary.value,
+                "problem": report.summary.problem,
+                "insight": report.summary.insight,
+                "show": report.summary.show,
+            }
+        print(json.dumps(data, indent=2))
+        return
+
+    if not report.has_changes:
+        print_info("No changes detected.")
+        console.print(f"[{BRAND_MUTED}]Working tree clean, nothing staged, up to date with remote.[/]")
+        raise typer.Exit()
+
+    # Get LLM client if explain mode
+    client = None
+    if explain:
+        from .openai_analysis import get_openai_client
+        client = get_openai_client()
+        if not client:
+            print_error("LLM not configured. Run `repr llm setup` first.")
+            raise typer.Exit(1)
+
+    # Header
+    console.print(f"[bold]Changes in {report.repo_path.name}[/]")
+    console.print()
+
+    # Unstaged changes
+    if report.unstaged:
+        console.print(f"[bold][{BRAND_WARNING}]Unstaged[/][/] ({len(report.unstaged)} files)")
+        # Explain this group right after header
+        if client:
+            with create_spinner("Explaining unstaged..."):
+                explanation = asyncio.run(explain_group("unstaged", file_changes=report.unstaged, client=client))
+            console.print()
+            console.print(f"[{BRAND_MUTED}]{explanation}[/]")
+            console.print()
+        for f in report.unstaged:
+            type_icon = {"A": "+", "M": "~", "D": "-", "R": "→"}.get(f.change_type, "?")
+            stats = ""
+            if f.insertions or f.deletions:
+                stats = f" [{BRAND_SUCCESS}]+{f.insertions}[/][{BRAND_ERROR}]-{f.deletions}[/]"
+            full_path = report.repo_path / f.path
+            console.print(f"  {type_icon} {full_path}{stats}")
+            # Show diff preview unless compact mode
+            if not compact and f.diff_preview:
+                for line in f.diff_preview.split("\n")[:10]:
+                    escaped_line = rich_escape(line)
+                    if line.startswith("+"):
+                        console.print(f"    [{BRAND_SUCCESS}]{escaped_line}[/]")
+                    elif line.startswith("-"):
+                        console.print(f"    [{BRAND_ERROR}]{escaped_line}[/]")
+        console.print()
+
+    # Staged changes
+    if report.staged:
+        console.print(f"[bold][{BRAND_SUCCESS}]Staged[/][/] ({len(report.staged)} files)")
+        # Explain this group right after header
+        if client:
+            with create_spinner("Explaining staged..."):
+                explanation = asyncio.run(explain_group("staged", file_changes=report.staged, client=client))
+            console.print()
+            console.print(f"[{BRAND_MUTED}]{explanation}[/]")
+            console.print()
+        for f in report.staged:
+            type_icon = {"A": "+", "M": "~", "D": "-", "R": "→"}.get(f.change_type, "?")
+            stats = ""
+            if f.insertions or f.deletions:
+                stats = f" [{BRAND_SUCCESS}]+{f.insertions}[/][{BRAND_ERROR}]-{f.deletions}[/]"
+            full_path = report.repo_path / f.path
+            console.print(f"  {type_icon} {full_path}{stats}")
+            # Show diff preview unless compact mode
+            if not compact and f.diff_preview:
+                for line in f.diff_preview.split("\n")[:10]:
+                    escaped_line = rich_escape(line)
+                    if line.startswith("+"):
+                        console.print(f"    [{BRAND_SUCCESS}]{escaped_line}[/]")
+                    elif line.startswith("-"):
+                        console.print(f"    [{BRAND_ERROR}]{escaped_line}[/]")
+        console.print()
+
+    # Unpushed commits
+    if report.unpushed:
+        console.print(f"[bold][{BRAND_PRIMARY}]Unpushed[/][/] ({len(report.unpushed)} commits)")
+        # Explain this group right after header
+        if client:
+            with create_spinner("Explaining unpushed..."):
+                explanation = asyncio.run(explain_group("unpushed", commit_changes=report.unpushed, client=client))
+            console.print()
+            console.print(f"[{BRAND_MUTED}]{explanation}[/]")
+            console.print()
+        for commit in report.unpushed:
+            console.print(f"  [{BRAND_MUTED}]{commit.sha}[/] {commit.message}")
+            # Show files changed in this commit
+            for f in commit.files[:5]:
+                type_icon = {"A": "+", "M": "~", "D": "-", "R": "→"}.get(f.change_type, "?")
+                full_path = report.repo_path / f.path
+                console.print(f"    {type_icon} {full_path}")
+            if len(commit.files) > 5:
+                console.print(f"    [{BRAND_MUTED}]... +{len(commit.files) - 5} more[/]")
+        console.print()
+
+
 @app.command()
 def mode(
     json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
@@ -2753,6 +4367,2211 @@ def doctor():
         print_error("Issues found - see recommendations above")
 
 
+# =============================================================================
+# MCP SERVER
+# =============================================================================
+
+@mcp_app.command("serve")
+def mcp_serve(
+    sse: bool = typer.Option(False, "--sse", help="Use SSE transport instead of stdio"),
+    port: int = typer.Option(3001, "--port", "-p", help="Port for SSE mode"),
+    host: str = typer.Option("127.0.0.1", "--host", "-h", help="Host for SSE mode"),
+):
+    """
+    Start the MCP server for AI agent integration.
+    
+    The MCP (Model Context Protocol) server exposes repr functionality
+    to AI agents like Claude Code, Cursor, Windsurf, and Cline.
+    
+    Examples:
+        repr mcp serve              # stdio mode (default)
+        repr mcp serve --sse        # SSE mode for remote clients
+        repr mcp serve --port 3001  # Custom port for SSE
+    
+    Configuration for Claude Code:
+        claude mcp add repr -- repr mcp serve
+    
+    Configuration for Cursor/Windsurf (mcp.json):
+        {
+          "mcpServers": {
+            "repr": {
+              "command": "repr",
+              "args": ["mcp", "serve"]
+            }
+          }
+        }
+    """
+    from .mcp_server import run_server
+    
+    if not sse:
+        # stdio mode - silent start, let MCP handle communication
+        run_server(sse=False)
+    else:
+        console.print(f"Starting MCP server (SSE mode) on {host}:{port}...")
+        run_server(sse=True, host=host, port=port)
+
+
+@mcp_app.command("info")
+def mcp_info():
+    """
+    Show MCP server configuration info.
+    
+    Example:
+        repr mcp info
+    """
+    console.print("[bold]MCP Server Info[/]")
+    console.print()
+    console.print("The MCP server exposes repr to AI agents via the Model Context Protocol.")
+    console.print()
+    console.print("[bold]Available Tools:[/]")
+    console.print("  • repr_generate    — Generate stories from commits")
+    console.print("  • repr_stories_list — List existing stories")
+    console.print("  • repr_week        — Weekly work summary")
+    console.print("  • repr_standup     — Yesterday/today summary")
+    console.print("  • repr_profile     — Get developer profile")
+    console.print()
+    console.print("[bold]Available Resources:[/]")
+    console.print("  • repr://profile        — Current profile")
+    console.print("  • repr://stories/recent — Recent stories")
+    console.print()
+    console.print("[bold]Usage:[/]")
+    console.print("  repr mcp serve              # Start server (stdio)")
+    console.print("  repr mcp serve --sse        # SSE mode")
+    console.print()
+    console.print("[bold]Claude Code setup:[/]")
+    console.print("  claude mcp add repr -- repr mcp serve")
+
+
+@mcp_app.command("install-skills")
+def mcp_install_skills(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing skill files"),
+):
+    """
+    Install repr skills to Claude Code.
+
+    Installs a skill that teaches Claude Code how and when to use repr commands
+    (init, generate, timeline, changes).
+
+    Example:
+        repr mcp install-skills
+        repr mcp install-skills --force  # Overwrite existing
+    """
+    skill_dir = Path.home() / ".claude" / "skills"
+    skill_file = skill_dir / "repr.md"
+
+    # Check if already installed
+    if skill_file.exists() and not force:
+        print_warning("repr skill already installed")
+        console.print(f"  Location: {skill_file}")
+        console.print()
+        console.print("Use --force to overwrite")
+        return
+
+    # Create directory
+    skill_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write skill file
+    skill_content = '''---
+name: repr
+description: Use this skill when the user asks to "show my changes", "what did I work on", "generate a story", "initialize repr", "show timeline", "set up repr", or needs context about their recent development work.
+version: 1.0.0
+---
+
+# repr - Developer Context Layer
+
+repr helps developers understand what they've actually worked on by analyzing git history and AI sessions.
+
+## When to Use repr
+
+- User asks about their recent work or changes
+- User wants to generate a story or summary from commits
+- User needs to set up repr for a project
+- User wants to see their development timeline
+- User asks "what did I work on" or similar
+
+## Commands
+
+### Initialize repr
+
+```bash
+# First-time setup - scan for repositories
+repr init
+
+# Scan specific directory
+repr init ~/projects
+```
+
+Use when: User is setting up repr for the first time or adding new repositories.
+
+### Show Changes
+
+```bash
+# Show current changes (unstaged, staged, unpushed)
+repr changes
+
+# Compact view (just file names)
+repr changes --compact
+
+# With LLM explanation
+repr changes --explain
+
+# JSON output
+repr changes --json
+```
+
+Use when: User asks "what are my changes", "show my work", "what's uncommitted", or needs to understand current git state.
+
+### Generate Stories
+
+```bash
+# Generate stories from recent commits
+repr generate
+
+# Generate for specific date range
+repr generate --since monday
+repr generate --since "2 weeks ago"
+
+# Use local LLM (Ollama)
+repr generate --local
+
+# Dry run (preview without saving)
+repr generate --dry-run
+```
+
+Use when: User wants to create narratives from their commits, document their work, or generate content for standup/weekly reports.
+
+### Timeline
+
+```bash
+# Initialize timeline for current project
+repr timeline init
+
+# Initialize with AI session ingestion
+repr timeline init --with-sessions
+
+# Show timeline entries
+repr timeline show
+repr timeline show --days 14
+
+# Filter by type
+repr timeline show --type commit
+repr timeline show --type session
+
+# Show timeline status
+repr timeline status
+
+# Refresh/update timeline
+repr timeline refresh
+
+# Launch web dashboard
+repr dashboard
+```
+
+Use when: User wants a unified view of commits and AI sessions, or needs to understand the full context of their development work.
+
+## Output Interpretation
+
+### Changes Output
+- **Unstaged**: Modified files not yet staged (with diff preview)
+- **Staged**: Changes ready to commit
+- **Unpushed**: Commits not yet pushed to remote
+
+### Timeline Entry Types
+- **commit**: Regular git commits
+- **session**: AI coding sessions (Claude Code, etc.)
+- **merged**: Commits with associated AI session context
+
+### Smart Git Workflow
+
+```bash
+# Stage files
+repr add .py              # Stage *.py files
+repr add .                # Stage all
+repr add src/             # Stage directory
+
+# Generate message and commit
+repr commit               # AI generates message
+repr commit -m "fix: x"   # Custom message
+repr commit -r            # Regenerate message
+
+# Push to remote
+repr push
+```
+
+Use when: User wants to stage, commit with AI-generated message, or push.
+
+## Tips
+
+1. Run `repr changes` before committing to see what you're about to commit
+2. Use `repr generate --dry-run` to preview stories before saving
+3. Initialize timeline with `--with-sessions` to capture AI context
+4. Use `repr timeline show --type session` to see AI-assisted work separately
+5. Use `repr commit add` for quick commits with AI-generated messages
+'''
+
+    skill_file.write_text(skill_content)
+
+    print_success("repr skill installed to Claude Code")
+    console.print()
+    console.print(f"  Skill: {skill_file}")
+    console.print()
+    console.print("Claude Code will now recognize repr commands.")
+    console.print("Try asking: 'show my changes' or 'what did I work on'")
+
+
+# =============================================================================
+# TIMELINE
+# =============================================================================
+
+@timeline_app.command("init")
+def timeline_init(
+    path: Optional[Path] = typer.Argument(
+        None,
+        help="Project path (default: current directory)",
+        exists=True,
+        dir_okay=True,
+        resolve_path=True,
+    ),
+    with_sessions: bool = typer.Option(
+        False, "--with-sessions", "-s",
+        help="Include AI session context (Claude Code, Clawdbot)",
+    ),
+    days: int = typer.Option(
+        90, "--days", "-d",
+        help="Number of days to look back",
+    ),
+    max_commits: int = typer.Option(
+        500, "--max-commits",
+        help="Maximum commits to include",
+    ),
+    model: str = typer.Option(
+        "openai/gpt-4.1-mini", "--model", "-m",
+        help="Model for session extraction (with --with-sessions)",
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f",
+        help="Overwrite existing timeline",
+    ),
+    json_output: bool = typer.Option(
+        False, "--json",
+        help="Output as JSON",
+    ),
+):
+    """
+    Initialize a project timeline from git commits and AI sessions.
+    
+    Creates .repr/timeline.json with unified context from:
+    - Git commits (always included)
+    - AI session logs (with --with-sessions flag)
+    
+    Examples:
+        repr timeline init                    # Commits only
+        repr timeline init --with-sessions    # Include AI sessions
+        repr timeline init --days 30          # Last 30 days
+        repr timeline init ~/myproject        # Specific project
+    """
+    from .timeline import (
+        detect_project_root,
+        is_initialized,
+        init_timeline_commits_only,
+        init_timeline_with_sessions_sync,
+        get_timeline_stats,
+    )
+    from .loaders import detect_session_source
+    
+    # Determine project path
+    project_path = path or Path.cwd()
+    
+    # Check if in git repo
+    repo_root = detect_project_root(project_path)
+    if not repo_root:
+        print_error(f"Not a git repository: {project_path}")
+        print_info("Run this command inside a git repository")
+        raise typer.Exit(1)
+    
+    project_path = repo_root
+    
+    # Check if already initialized
+    if is_initialized(project_path) and not force:
+        print_warning(f"Timeline already exists for {project_path}")
+        print_info("Use --force to reinitialize")
+        raise typer.Exit(1)
+    
+    if not json_output:
+        print_header()
+        console.print(f"Initializing timeline for [bold]{project_path.name}[/]")
+        console.print()
+    
+    # Check for session sources if --with-sessions
+    session_sources = []
+    if with_sessions:
+        session_sources = detect_session_source(project_path)
+        if not session_sources:
+            if not json_output:
+                print_warning("No AI session sources found for this project")
+                print_info("Supported: Claude Code (~/.claude/projects/), Clawdbot (~/.clawdbot/)")
+                if not confirm("Continue with commits only?", default=True):
+                    raise typer.Exit(0)
+            with_sessions = False
+        else:
+            if not json_output:
+                console.print(f"Session sources: {', '.join(session_sources)}")
+    
+    # Progress tracking
+    progress_state = {"stage": "", "current": 0, "total": 0}
+    
+    def progress_callback(stage: str, current: int, total: int) -> None:
+        progress_state["stage"] = stage
+        progress_state["current"] = current
+        progress_state["total"] = total
+    
+    try:
+        if with_sessions:
+            # Get API key for extraction
+            # Priority: BYOK OpenAI > env OPENAI_API_KEY > LiteLLM (cloud)
+            api_key = None
+            byok_config = get_byok_config("openai")
+            if byok_config:
+                api_key = byok_config.get("api_key")
+            
+            if not api_key:
+                # Try environment variable (direct OpenAI access)
+                api_key = os.environ.get("OPENAI_API_KEY")
+            
+            if not api_key:
+                # Try LiteLLM config (cloud mode - needs LiteLLM proxy URL)
+                _, litellm_key = get_litellm_config()
+                api_key = litellm_key
+            
+            if not api_key:
+                if not json_output:
+                    print_warning("No API key configured for session extraction")
+                    print_info("Configure with: repr llm add openai")
+                    print_info("Or set OPENAI_API_KEY environment variable")
+                    if not confirm("Continue with commits only?", default=True):
+                        raise typer.Exit(0)
+                with_sessions = False
+        
+        if with_sessions:
+            if not json_output:
+                with create_spinner() as progress:
+                    task = progress.add_task("Initializing...", total=None)
+                    timeline = init_timeline_with_sessions_sync(
+                        project_path,
+                        days=days,
+                        max_commits=max_commits,
+                        session_sources=session_sources,
+                        api_key=api_key,
+                        model=model,
+                        progress_callback=progress_callback,
+                    )
+            else:
+                timeline = init_timeline_with_sessions_sync(
+                    project_path,
+                    days=days,
+                    max_commits=max_commits,
+                    session_sources=session_sources,
+                    api_key=api_key,
+                    model=model,
+                )
+        else:
+            if not json_output:
+                with create_spinner() as progress:
+                    task = progress.add_task("Scanning commits...", total=None)
+                    timeline = init_timeline_commits_only(
+                        project_path,
+                        days=days,
+                        max_commits=max_commits,
+                        progress_callback=progress_callback,
+                    )
+            else:
+                timeline = init_timeline_commits_only(
+                    project_path,
+                    days=days,
+                    max_commits=max_commits,
+                )
+        
+        # Get stats
+        stats = get_timeline_stats(timeline)
+        
+        if json_output:
+            print(json.dumps({
+                "success": True,
+                "project": str(project_path),
+                "timeline_path": str(project_path / ".repr" / "timeline.json"),
+                "stats": stats,
+            }, indent=2))
+        else:
+            console.print()
+            print_success(f"Timeline initialized!")
+            console.print()
+            console.print(f"  Location: .repr/timeline.json")
+            console.print(f"  Entries: {stats['total_entries']}")
+            console.print(f"    Commits: {stats['commit_count']}")
+            if stats['merged_count'] > 0:
+                console.print(f"    Merged (commit + session): {stats['merged_count']}")
+            if stats['session_count'] > 0:
+                console.print(f"    Sessions only: {stats['session_count']}")
+            if stats['date_range']['first']:
+                console.print(f"  Date range: {stats['date_range']['first'][:10]} to {stats['date_range']['last'][:10]}")
+            
+            console.print()
+            print_next_steps([
+                "repr timeline status      View timeline status",
+                "repr timeline show        Browse timeline entries",
+            ])
+    
+    except Exception as e:
+        if json_output:
+            print(json.dumps({"success": False, "error": str(e)}, indent=2))
+        else:
+            print_error(f"Failed to initialize timeline: {e}")
+        raise typer.Exit(1)
+
+
+@timeline_app.command("status")
+def timeline_status(
+    path: Optional[Path] = typer.Argument(
+        None,
+        help="Project path (default: current directory)",
+        exists=True,
+        dir_okay=True,
+        resolve_path=True,
+    ),
+    json_output: bool = typer.Option(
+        False, "--json",
+        help="Output as JSON",
+    ),
+):
+    """
+    Show timeline status for a project.
+    
+    Example:
+        repr timeline status
+    """
+    from .timeline import (
+        detect_project_root,
+        is_initialized,
+        load_timeline,
+        get_timeline_stats,
+    )
+    
+    # Determine project path
+    project_path = path or Path.cwd()
+    repo_root = detect_project_root(project_path)
+    
+    if not repo_root:
+        print_error(f"Not a git repository: {project_path}")
+        raise typer.Exit(1)
+    
+    project_path = repo_root
+    
+    if not is_initialized(project_path):
+        if json_output:
+            print(json.dumps({"initialized": False, "project": str(project_path)}, indent=2))
+        else:
+            print_warning(f"Timeline not initialized for {project_path.name}")
+            print_info("Run: repr timeline init")
+        raise typer.Exit(1)
+    
+    timeline = load_timeline(project_path)
+    if not timeline:
+        print_error("Failed to load timeline")
+        raise typer.Exit(1)
+    
+    stats = get_timeline_stats(timeline)
+    
+    if json_output:
+        print(json.dumps({
+            "initialized": True,
+            "project": str(project_path),
+            "stats": stats,
+            "last_updated": timeline.last_updated.isoformat() if timeline.last_updated else None,
+        }, indent=2))
+    else:
+        print_header()
+        console.print(f"Timeline: [bold]{project_path.name}[/]")
+        console.print()
+        console.print(f"  Entries: {stats['total_entries']}")
+        console.print(f"    Commits: {stats['commit_count']}")
+        console.print(f"    Merged: {stats['merged_count']}")
+        console.print(f"    Sessions: {stats['session_count']}")
+        if stats['date_range']['first']:
+            console.print(f"  Date range: {stats['date_range']['first'][:10]} to {stats['date_range']['last'][:10]}")
+        if stats['session_sources']:
+            console.print(f"  Session sources: {', '.join(stats['session_sources'])}")
+        if timeline.last_updated:
+            last_updated_str = timeline.last_updated.isoformat() if hasattr(timeline.last_updated, 'isoformat') else str(timeline.last_updated)
+            console.print(f"  Last updated: {format_relative_time(last_updated_str)}")
+
+
+@timeline_app.command("show")
+def timeline_show(
+    path: Optional[str] = typer.Argument(
+        None,
+        help="Project path (use '.' for current repo, omit for all repos)",
+    ),
+    days: int = typer.Option(
+        7, "--days", "-d",
+        help="Show entries from last N days",
+    ),
+    entry_type: Optional[str] = typer.Option(
+        None, "--type", "-t",
+        help="Filter by type: commit, session, merged",
+    ),
+    limit: int = typer.Option(
+        20, "--limit", "-n",
+        help="Maximum entries to show",
+    ),
+    json_output: bool = typer.Option(
+        False, "--json",
+        help="Output as JSON",
+    ),
+    public: bool = typer.Option(
+        True, "--public/--no-public",
+        help="Build-in-public feed format (default)",
+    ),
+    internal: bool = typer.Option(
+        False, "--internal",
+        help="Show technical details in feed",
+    ),
+    raw: bool = typer.Option(
+        False, "--raw",
+        help="Show raw timeline entries (commits/sessions)",
+    ),
+    all_repos: bool = typer.Option(
+        False, "--all", "-a",
+        help="Show stories from all tracked repos (default when no path given)",
+    ),
+    group: bool = typer.Option(
+        False, "--group", "-g",
+        help="Group stories by project (presentation view)",
+    ),
+):
+    """
+    Show timeline entries.
+
+    Examples:
+        repr timeline show                    # All tracked repos from database
+        repr timeline show .                  # Current repo only
+        repr timeline show /path/to/repo      # Specific repo
+        repr timeline show --group            # All repos, grouped by project
+        repr timeline show . --days 30        # Current repo, last 30 days
+        repr timeline show --internal         # Feed format with tech details
+    """
+    from datetime import timezone
+    from .timeline import (
+        detect_project_root,
+        is_initialized,
+        load_timeline,
+        query_timeline,
+    )
+    from .models import TimelineEntryType
+    from .db import get_db
+
+    db = get_db()
+    since = datetime.now(timezone.utc) - timedelta(days=days)
+
+    # Determine mode: all repos (no path) vs specific repo (path given)
+    show_all_repos = path is None and not raw
+
+    # If --all flag is given, always show all repos
+    if all_repos:
+        show_all_repos = True
+
+    project_path = None
+    timeline = None
+    entries = []
+
+    if not show_all_repos:
+        # Specific repo mode - resolve path
+        resolved_path = Path(path) if path else Path.cwd()
+        if not resolved_path.is_absolute():
+            resolved_path = Path.cwd() / resolved_path
+        resolved_path = resolved_path.resolve()
+
+        repo_root = detect_project_root(resolved_path)
+
+        if not repo_root:
+            print_error(f"Not a git repository: {resolved_path}")
+            raise typer.Exit(1)
+
+        project_path = repo_root
+
+        if not is_initialized(project_path):
+            print_warning(f"Timeline not initialized for {project_path.name}")
+            print_info("Run: repr timeline init")
+            raise typer.Exit(1)
+
+        timeline = load_timeline(project_path)
+        if not timeline:
+            print_error("Failed to load timeline")
+            raise typer.Exit(1)
+
+        # Parse entry type filter
+        entry_types = None
+        if entry_type:
+            try:
+                entry_types = [TimelineEntryType(entry_type)]
+            except ValueError:
+                print_error(f"Invalid type: {entry_type}")
+                print_info("Valid types: commit, session, merged")
+                raise typer.Exit(1)
+
+        # Query entries
+        entries = query_timeline(timeline, since=since, entry_types=entry_types)
+        entries = entries[-limit:]  # Take most recent
+
+    if json_output:
+        if show_all_repos:
+            # JSON output for all repos
+            stories = db.list_stories(since=since, limit=limit)
+            print(json.dumps({
+                "mode": "all_repos",
+                "stories": [{"id": s.id, "title": s.title, "project_id": s.project_id} for s in stories],
+            }, indent=2))
+        else:
+            from .timeline import _serialize_entry
+            print(json.dumps({
+                "project": str(project_path),
+                "entries": [_serialize_entry(e) for e in entries],
+            }, indent=2))
+        return
+
+    if not show_all_repos and not entries:
+        print_info(f"No entries in the last {days} days")
+        return
+
+    # Feed format (default, unless --raw)
+    if not raw:
+        # Build project lookup
+        projects = {p["id"]: p["name"] for p in db.list_projects()}
+
+        if show_all_repos:
+            # Show stories from all repos
+            stories = db.list_stories(since=since, limit=limit)
+            header_name = "all repos"
+        else:
+            # Show stories from current repo only
+            project = db.get_project_by_path(project_path)
+
+            if not project:
+                print_info(f"No stories found. Run 'repr generate' first.")
+                return
+
+            stories = db.list_stories(project_id=project["id"], since=since, limit=limit)
+            header_name = project_path.name
+
+        if not stories:
+            print_info(f"No stories in the last {days} days. Run 'repr generate' first.")
+            return
+
+        def format_rel_time(story_time):
+            """Format timestamp as relative time."""
+            local_time = story_time.astimezone()
+            now = datetime.now(local_time.tzinfo)
+            delta = now - local_time
+
+            if delta.days == 0:
+                if delta.seconds < 3600:
+                    return f"{delta.seconds // 60}m ago"
+                else:
+                    return f"{delta.seconds // 3600}h ago"
+            elif delta.days == 1:
+                return "Yesterday"
+            elif delta.days < 7:
+                return f"{delta.days} days ago"
+            else:
+                return local_time.strftime("%b %d")
+
+        def render_story(story, show_repo=False):
+            """Render a single story entry using Tripartite Codex structure."""
+            story_time = story.started_at or story.created_at
+            rel_time = format_rel_time(story_time)
+            repo_name = projects.get(story.project_id, "unknown")
+
+            # Header with time and optional repo
+            if show_repo:
+                console.print(f"[{BRAND_PRIMARY}]{repo_name}[/] · [{BRAND_MUTED}]{rel_time}[/]")
+            else:
+                console.print(f"[{BRAND_MUTED}]{rel_time}[/]")
+
+            # Use structured fields if available, fall back to legacy
+            if story.hook:
+                # New Tripartite Codex format
+                console.print(f"[bold]{story.hook}[/]")
+                console.print()
+                what_text = story.what.rstrip(".").rstrip()
+                value_text = story.value.lstrip(".").lstrip()
+                console.print(f"{what_text}. {value_text}")
+
+                # Show block if present
+                if story.show:
+                    console.print()
+                    console.print(f"```\n{story.show}\n```")
+
+                # Diagram if present
+                if story.diagram:
+                    console.print()
+                    console.print(f"[{BRAND_MUTED}]Diagram:[/]")
+                    console.print(f"```\n{story.diagram}\n```")
+
+                # Internal mode: show problem and how
+                if internal:
+                    if story.problem:
+                        console.print()
+                        console.print(f"[{BRAND_MUTED}]Problem:[/] {story.problem}")
+
+                    if story.implementation_details:
+                        console.print()
+                        console.print(f"[{BRAND_MUTED}]How:[/]")
+                        for detail in story.implementation_details[:5]:
+                            console.print(f"  [{BRAND_MUTED}]›[/] {detail}")
+
+                # Insight
+                if story.insight:
+                    console.print()
+                    console.print(f"[{BRAND_MUTED}]Insight:[/] {story.insight}")
+
+            else:
+                # Legacy format fallback
+                post_text = story.public_post or story.title
+                if internal:
+                    post_text = story.internal_post or post_text
+                console.print(post_text)
+
+                show_block = story.show or story.public_show
+                if internal:
+                    show_block = show_block or story.internal_show
+                if show_block:
+                    console.print()
+                    console.print(f"```\n{show_block}\n```")
+
+                if internal and story.internal_details:
+                    console.print()
+                    console.print(f"[{BRAND_MUTED}]Implementation:[/]")
+                    for detail in story.internal_details[:5]:
+                        console.print(f"  [{BRAND_MUTED}]›[/] {detail}")
+
+            # Recall data (internal mode only) - file changes and snippets
+            if internal:
+                # File changes summary
+                if story.file_changes:
+                    total_changes = f"+{story.total_insertions}/-{story.total_deletions}" if (story.total_insertions or story.total_deletions) else ""
+                    console.print()
+                    console.print(f"[{BRAND_MUTED}]Files changed ({len(story.file_changes)})[/] [{BRAND_MUTED}]{total_changes}[/]")
+                    for fc in story.file_changes[:8]:  # Show up to 8 files
+                        change_indicator = {"added": "+", "deleted": "-", "modified": "~"}.get(fc.change_type, "~")
+                        stats = f"[green]+{fc.insertions}[/][{BRAND_MUTED}]/[/][red]-{fc.deletions}[/]" if (fc.insertions or fc.deletions) else ""
+                        console.print(f"  [{BRAND_MUTED}]{change_indicator}[/] {fc.file_path} {stats}")
+                    if len(story.file_changes) > 8:
+                        console.print(f"  [{BRAND_MUTED}]... and {len(story.file_changes) - 8} more files[/]")
+
+                # Key code snippets
+                if story.key_snippets:
+                    console.print()
+                    console.print(f"[{BRAND_MUTED}]Snippets:[/]")
+                    for snippet in story.key_snippets[:2]:  # Show up to 2 snippets
+                        lang = snippet.language or ""
+                        console.print(f"  [{BRAND_MUTED}]{snippet.file_path}[/]")
+                        console.print(f"```{lang}\n{snippet.content}\n```")
+
+            console.print()
+            console.print(f"[{BRAND_MUTED}]{'─' * 60}[/]")
+            console.print()
+
+        print_header()
+
+        if group and all_repos:
+            # Grouped view: organize by project
+            console.print(f"[bold]@all repos[/] · build log [dim](grouped)[/]")
+            console.print()
+
+            # Group stories by project
+            from collections import defaultdict
+            stories_by_project = defaultdict(list)
+            for story in stories:
+                stories_by_project[story.project_id].append(story)
+
+            # Render each project group
+            for project_id, project_stories in stories_by_project.items():
+                project_name = projects.get(project_id, "unknown")
+                console.print(f"[bold]── {project_name} ──[/]")
+                console.print()
+
+                for story in project_stories:
+                    render_story(story, show_repo=False)
+
+        else:
+            # Timeline view (default)
+            console.print(f"[bold]@{header_name}[/] · build log")
+            console.print()
+
+            for story in stories:
+                render_story(story, show_repo=all_repos)
+
+        return
+
+    # Default format (unchanged)
+    print_header()
+    console.print(f"Timeline: [bold]{project_path.name}[/] (last {days} days)")
+    console.print()
+
+    for entry in reversed(entries):  # Show newest first
+        # Format timestamp (convert to local timezone)
+        local_ts = entry.timestamp.astimezone()
+        ts = local_ts.strftime("%Y-%m-%d %H:%M")
+
+        # Entry type indicator
+        if entry.type == TimelineEntryType.COMMIT:
+            type_icon = "📝"
+        elif entry.type == TimelineEntryType.SESSION:
+            type_icon = "💬"
+        else:  # MERGED
+            type_icon = "🔗"
+
+        # Build description
+        if entry.commit:
+            # Show first line of commit message
+            msg = entry.commit.message.split("\n")[0][:60]
+            if len(entry.commit.message.split("\n")[0]) > 60:
+                msg += "..."
+            desc = f"{msg}"
+            sha = entry.commit.sha[:8]
+            console.print(f"{type_icon} [{BRAND_MUTED}]{ts}[/] [{BRAND_PRIMARY}]{sha}[/] {desc}")
+        elif entry.session_context:
+            # Show problem from session
+            problem = entry.session_context.problem[:60]
+            if len(entry.session_context.problem) > 60:
+                problem += "..."
+            console.print(f"{type_icon} [{BRAND_MUTED}]{ts}[/] {problem}")
+
+        # Show session context if merged
+        if entry.type == TimelineEntryType.MERGED and entry.session_context:
+            console.print(f"    [{BRAND_MUTED}]→ {entry.session_context.problem[:70]}[/]")
+
+        console.print()
+
+
+@timeline_app.command("refresh")
+def timeline_refresh(
+    path: Optional[str] = typer.Argument(
+        None,
+        help="Project path (use '.' for current repo, omit for all repos)",
+    ),
+    limit: int = typer.Option(
+        50, "--limit", "-n",
+        help="Maximum stories to refresh",
+    ),
+    json_output: bool = typer.Option(
+        False, "--json",
+        help="Output as JSON",
+    ),
+):
+    """
+    Regenerate posts for existing stories.
+
+    This updates the public_post and internal_post fields without
+    re-analyzing commits. Useful after prompt improvements.
+
+    Examples:
+        repr timeline refresh              # Refresh all repos
+        repr timeline refresh .            # Refresh current repo only
+        repr timeline refresh --limit 10   # Refresh last 10 stories
+    """
+    from .db import get_db
+    from .story_synthesis import (
+        transform_story_for_feed_sync,
+        _build_fallback_post,
+        extract_file_changes_from_commits,
+        extract_key_snippets_from_commits,
+    )
+
+    db = get_db()
+
+    # Determine scope
+    if path is None:
+        # All repos
+        stories = db.list_stories(limit=limit)
+        scope_name = "all repos"
+    else:
+        # Specific repo
+        from .timeline import detect_project_root
+        resolved_path = Path(path) if path else Path.cwd()
+        if not resolved_path.is_absolute():
+            resolved_path = Path.cwd() / resolved_path
+        resolved_path = resolved_path.resolve()
+
+        repo_root = detect_project_root(resolved_path)
+        if not repo_root:
+            print_error(f"Not a git repository: {resolved_path}")
+            raise typer.Exit(1)
+
+        project = db.get_project_by_path(repo_root)
+        if not project:
+            print_error(f"No stories found for {repo_root.name}")
+            raise typer.Exit(1)
+
+        stories = db.list_stories(project_id=project["id"], limit=limit)
+        scope_name = repo_root.name
+
+    if not stories:
+        print_info("No stories to refresh")
+        return
+
+    print_header()
+    console.print(f"Refreshing {len(stories)} stories from {scope_name}...")
+    console.print()
+
+    refreshed = 0
+    failed = 0
+
+    # Get project paths for file extraction
+    project_paths = {}
+    for p in db.list_projects():
+        project_paths[p["id"]] = p["path"]
+
+    for story in stories:
+        try:
+            # Extract file changes and snippets from git
+            project_path = project_paths.get(story.project_id)
+            if story.commit_shas and project_path:
+                file_changes, total_ins, total_del = extract_file_changes_from_commits(
+                    story.commit_shas, project_path
+                )
+                story.file_changes = file_changes
+                story.total_insertions = total_ins
+                story.total_deletions = total_del
+                story.key_snippets = extract_key_snippets_from_commits(
+                    story.commit_shas, project_path, max_snippets=3
+                )
+
+            # Regenerate Tripartite Codex content
+            result = transform_story_for_feed_sync(story, mode="internal")
+
+            # Store structured fields
+            story.hook = result.hook
+            story.what = result.what
+            story.value = result.value
+            story.insight = result.insight
+            story.show = result.show
+            story.post_body = result.post_body
+
+            # Internal-specific fields
+            if hasattr(result, 'problem') and result.problem:
+                story.problem = result.problem
+            if hasattr(result, 'how') and result.how:
+                story.implementation_details = result.how
+
+            # Legacy fields for backward compatibility
+            what_clean = result.what.rstrip(".").rstrip()
+            value_clean = result.value.lstrip(".").lstrip()
+            story.public_post = f"{result.hook}\n\n{what_clean}. {value_clean}\n\nInsight: {result.insight}"
+            story.internal_post = story.public_post
+            story.public_show = result.show
+            story.internal_show = result.show
+
+            # Update in database
+            db.save_story(story, story.project_id)
+            refreshed += 1
+
+            if not json_output:
+                console.print(f"  [green]✓[/] {story.title[:60]}")
+
+        except Exception as e:
+            # Use fallback
+            fallback_post = _build_fallback_post(story)
+            story.public_post = fallback_post
+            story.internal_post = fallback_post
+            db.save_story(story, story.project_id)
+            failed += 1
+
+            if not json_output:
+                console.print(f"  [yellow]![/] {story.title[:60]} (fallback)")
+
+    console.print()
+
+    if json_output:
+        print(json.dumps({"refreshed": refreshed, "failed": failed}))
+    else:
+        print_success(f"Refreshed {refreshed} stories" + (f" ({failed} used fallback)" if failed else ""))
+
+
+@timeline_app.command("ingest-session")
+def timeline_ingest_session(
+    file: Path = typer.Option(
+        ..., "--file", "-f",
+        help="Path to session file (JSONL)",
+        exists=True,
+        file_okay=True,
+        resolve_path=True,
+    ),
+    project: Optional[Path] = typer.Option(
+        None, "--project", "-p",
+        help="Project path (default: detected from session cwd)",
+        exists=True,
+        dir_okay=True,
+        resolve_path=True,
+    ),
+    source: Optional[str] = typer.Option(
+        None, "--source", "-s",
+        help="Session source: claude_code, clawdbot (default: auto-detect)",
+    ),
+    model: str = typer.Option(
+        "openai/gpt-4.1-mini", "--model", "-m",
+        help="Model for context extraction",
+    ),
+    json_output: bool = typer.Option(
+        False, "--json",
+        help="Output as JSON",
+    ),
+):
+    """
+    Ingest a completed AI session into the timeline.
+    
+    Called by SessionEnd hooks to capture context from AI coding sessions.
+    
+    Examples:
+        repr timeline ingest-session --file ~/.claude/projects/.../session.jsonl
+        repr timeline ingest-session --file /path/to/session.jsonl --project ~/myproject
+    """
+    from datetime import timezone
+    from .timeline import (
+        detect_project_root,
+        is_initialized,
+        load_timeline,
+        save_timeline,
+        extract_commits_from_git,
+    )
+    from .models import (
+        TimelineEntry,
+        TimelineEntryType,
+        match_commits_to_sessions,
+    )
+    from .loaders import ClaudeCodeLoader, ClawdbotLoader
+    from .session_extractor import SessionExtractor
+    
+    # Determine source
+    if source is None:
+        if ".claude" in str(file):
+            source = "claude_code"
+        elif ".clawdbot" in str(file):
+            source = "clawdbot"
+        else:
+            # Try both loaders
+            source = "claude_code"
+    
+    # Load session
+    if source == "claude_code":
+        loader = ClaudeCodeLoader()
+    elif source == "clawdbot":
+        loader = ClawdbotLoader()
+    else:
+        print_error(f"Unknown source: {source}")
+        raise typer.Exit(1)
+    
+    session = loader.load_session(file)
+    if not session:
+        if json_output:
+            print(json.dumps({"success": False, "error": "Failed to load session"}))
+        else:
+            print_error(f"Failed to load session from {file}")
+        raise typer.Exit(1)
+    
+    # Determine project path
+    if project is None:
+        if session.cwd:
+            project = detect_project_root(Path(session.cwd))
+        if project is None:
+            if json_output:
+                print(json.dumps({"success": False, "error": "Could not detect project path"}))
+            else:
+                print_error("Could not detect project path from session")
+                print_info("Specify with --project /path/to/repo")
+            raise typer.Exit(1)
+    
+    project_path = project
+    
+    # Check if timeline exists
+    if not is_initialized(project_path):
+        if json_output:
+            print(json.dumps({"success": False, "error": f"Timeline not initialized for {project_path}"}))
+        else:
+            print_warning(f"Timeline not initialized for {project_path.name}")
+            print_info("Run: repr timeline init")
+        raise typer.Exit(1)
+    
+    # Load existing timeline
+    timeline = load_timeline(project_path)
+    if not timeline:
+        print_error("Failed to load timeline")
+        raise typer.Exit(1)
+    
+    # Check if session already ingested
+    for entry in timeline.entries:
+        if entry.session_context and entry.session_context.session_id == session.id:
+            if json_output:
+                print(json.dumps({"success": True, "skipped": True, "reason": "Session already ingested"}))
+            else:
+                print_info(f"Session {session.id[:8]} already ingested")
+            return
+    
+    # Get API key for extraction
+    api_key = None
+    byok_config = get_byok_config("openai")
+    if byok_config:
+        api_key = byok_config.get("api_key")
+    
+    if not api_key:
+        _, litellm_key = get_litellm_config()
+        api_key = litellm_key
+    
+    if not api_key:
+        api_key = os.environ.get("OPENAI_API_KEY")
+    
+    if not api_key:
+        if json_output:
+            print(json.dumps({"success": False, "error": "No API key for extraction"}))
+        else:
+            print_error("No API key configured for session extraction")
+            print_info("Configure with: repr llm add openai")
+        raise typer.Exit(1)
+    
+    # Extract context from session
+    async def _extract():
+        extractor = SessionExtractor(api_key=api_key, model=model)
+        return await extractor.extract_context(session)
+    
+    if not json_output:
+        with create_spinner() as progress:
+            task = progress.add_task("Extracting context...", total=None)
+            context = asyncio.run(_extract())
+    else:
+        context = asyncio.run(_extract())
+    
+    # Get recent commits to potentially link
+    recent_commits = extract_commits_from_git(
+        project_path,
+        days=1,  # Just last day for linking
+        max_commits=50,
+    )
+    
+    # Match session to commits
+    if recent_commits:
+        matches = match_commits_to_sessions(recent_commits, [session])
+        linked_commits = [m.commit_sha for m in matches if m.session_id == session.id]
+        context.linked_commits = linked_commits
+    
+    # Create timeline entry
+    entry_type = TimelineEntryType.SESSION
+    if context.linked_commits:
+        # Find and upgrade matching commit entries to MERGED
+        for commit_sha in context.linked_commits:
+            for entry in timeline.entries:
+                if entry.commit and entry.commit.sha == commit_sha:
+                    entry.session_context = context
+                    entry.type = TimelineEntryType.MERGED
+                    entry_type = None  # Don't create standalone entry
+                    break
+            if entry_type is None:
+                break
+    
+    # Add standalone session entry if not merged
+    if entry_type is not None:
+        entry = TimelineEntry(
+            timestamp=context.timestamp,
+            type=entry_type,
+            commit=None,
+            session_context=context,
+            story=None,
+        )
+        timeline.add_entry(entry)
+    
+    # Save timeline
+    save_timeline(timeline, project_path)
+    
+    if json_output:
+        print(json.dumps({
+            "success": True,
+            "session_id": session.id,
+            "project": str(project_path),
+            "problem": context.problem[:100],
+            "linked_commits": context.linked_commits,
+            "entry_type": entry_type.value if entry_type else "merged",
+        }, indent=2))
+    else:
+        print_success(f"Session ingested!")
+        console.print()
+        console.print(f"  Session: {session.id[:8]}")
+        console.print(f"  Problem: {context.problem[:60]}...")
+        if context.linked_commits:
+            console.print(f"  Linked to commits: {', '.join(c[:8] for c in context.linked_commits)}")
+        console.print(f"  Entry type: {entry_type.value if entry_type else 'merged'}")
+
+
+@timeline_app.command("serve", hidden=True)
+def timeline_serve(
+    port: int = typer.Option(
+        8787, "--port", "-p",
+        help="Port to serve on",
+    ),
+    host: str = typer.Option(
+        "127.0.0.1", "--host",
+        help="Host to bind to",
+    ),
+    open_browser: bool = typer.Option(
+        True, "--open/--no-open",
+        help="Auto-open browser (default: enabled)",
+    ),
+):
+    """
+    [Deprecated] Use 'repr dashboard' instead.
+
+    Alias for backward compatibility - calls 'repr dashboard'.
+    """
+    print_info("Note: 'repr timeline serve' is deprecated. Use 'repr dashboard' instead.")
+    dashboard(port=port, host=host, open_browser=open_browser)
+
+
+# =============================================================================
+# GIT WORKFLOW COMMANDS (add, commit, push)
+# =============================================================================
+
+# File-based cache for commit message (persists between commands)
+_COMMIT_MSG_CACHE_FILE = Path.home() / ".repr" / ".commit_message_cache"
+
+
+COMMIT_MESSAGE_SYSTEM = """You generate git commit messages and branch names. Given staged changes, output JSON with:
+
+{
+  "branch": "<type>/<short-description>",
+  "message": "<type>: <description>"
+}
+
+Types: feat, fix, refactor, docs, style, test, chore
+
+Rules:
+- Branch: lowercase, hyphens, no spaces (e.g., feat/add-user-auth)
+- Message: under 72 chars, imperative mood, no period at end
+
+Output only valid JSON."""
+
+COMMIT_MESSAGE_USER = """Generate branch name and commit message for these staged changes:
+
+{changes}"""
+
+
+def _get_cached_commit_info() -> Optional[dict]:
+    """Get cached commit info (branch + message) if it exists."""
+    if _COMMIT_MSG_CACHE_FILE.exists():
+        try:
+            return json.loads(_COMMIT_MSG_CACHE_FILE.read_text())
+        except Exception:
+            return None
+    return None
+
+
+def _set_cached_commit_info(branch: str, message: str):
+    """Cache the commit info."""
+    _COMMIT_MSG_CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    _COMMIT_MSG_CACHE_FILE.write_text(json.dumps({"branch": branch, "message": message}))
+
+
+def _clear_cached_commit_info():
+    """Clear the cached commit info."""
+    if _COMMIT_MSG_CACHE_FILE.exists():
+        _COMMIT_MSG_CACHE_FILE.unlink()
+
+
+@app.command("clear")
+def clear_cache():
+    """
+    Clear cached branch name and commit message.
+
+    Examples:
+        repr clear
+    """
+    cached = _get_cached_commit_info()
+    if cached:
+        console.print(f"[{BRAND_MUTED}]Clearing cached:[/]")
+        if cached.get("branch"):
+            console.print(f"  Branch: {cached['branch']}")
+        if cached.get("message"):
+            console.print(f"  Message: {cached['message']}")
+        _clear_cached_commit_info()
+        print_success("Cache cleared")
+    else:
+        print_info("No cached branch/message")
+
+
+@app.command("add")
+def add_files(
+    pattern: str = typer.Argument(..., help="File pattern to stage (glob pattern)"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force add ignored files"),
+):
+    """
+    Stage files matching pattern.
+
+    Run `repr commit` to generate a message and commit.
+
+    Examples:
+        repr add cli              # Stage files containing "cli"
+        repr add .py              # Stage files containing ".py"
+        repr add .                # Stage all
+        repr add cli -f           # Force add ignored files
+    """
+    import subprocess
+    from .change_synthesis import get_repo, get_staged_changes
+
+    repo = get_repo(Path.cwd())
+    if not repo:
+        print_error("Not a git repository")
+        raise typer.Exit(1)
+
+    # Special case: "." means all
+    if pattern == ".":
+        try:
+            cmd = ["git", "add", "."]
+            if force:
+                cmd.insert(2, "-f")
+            result = subprocess.run(cmd, cwd=repo.working_dir, capture_output=True, text=True)
+            if result.returncode != 0:
+                print_error(f"Failed to stage files: {result.stderr}")
+                raise typer.Exit(1)
+        except Exception as e:
+            print_error(f"Failed to stage files: {e}")
+            raise typer.Exit(1)
+    else:
+        # Grep-style match: find files containing pattern
+        # Get modified/untracked files
+        status_result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=repo.working_dir,
+            capture_output=True,
+            text=True,
+        )
+        if status_result.returncode != 0:
+            print_error(f"Failed to get status: {status_result.stderr}")
+            raise typer.Exit(1)
+
+        # Parse status output and filter by pattern (grep-style regex)
+        import re
+        matching_files = []
+        try:
+            regex = re.compile(pattern, re.IGNORECASE)
+        except re.error:
+            # Fall back to literal match if invalid regex
+            regex = re.compile(re.escape(pattern), re.IGNORECASE)
+
+        for line in status_result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            # Format: XY filename or XY orig -> renamed (XY is 2 chars, then optional space)
+            file_path = line[2:].lstrip().split(" -> ")[-1].strip()
+            if regex.search(file_path):
+                matching_files.append(file_path)
+
+        if not matching_files:
+            print_warning(f"No changed files matching '{pattern}'")
+            raise typer.Exit(0)
+
+        # Stage matching files
+        try:
+            cmd = ["git", "add"]
+            if force:
+                cmd.append("-f")
+            cmd.extend(matching_files)
+            result = subprocess.run(cmd, cwd=repo.working_dir, capture_output=True, text=True)
+            if result.returncode != 0:
+                print_error(f"Failed to stage files: {result.stderr}")
+                raise typer.Exit(1)
+        except Exception as e:
+            print_error(f"Failed to stage files: {e}")
+            raise typer.Exit(1)
+
+    staged = get_staged_changes(repo)
+    if not staged:
+        print_warning("No files matched pattern or nothing to stage")
+        raise typer.Exit(0)
+
+    # Clear cached branch/message so next commit generates fresh
+    _clear_cached_commit_info()
+
+    # Show staged files
+    console.print(f"[bold]Staged {len(staged)} files[/]")
+    for f in staged:
+        type_icon = {"A": "+", "M": "~", "D": "-", "R": "→"}.get(f.change_type, "?")
+        stats = ""
+        if f.insertions or f.deletions:
+            stats = f" [{BRAND_SUCCESS}]+{f.insertions}[/][{BRAND_ERROR}]-{f.deletions}[/]"
+        console.print(f"  {type_icon} {f.path}{stats}")
+    console.print()
+
+    # Suggest branch if on main/master, otherwise commit
+    try:
+        branch_name = repo.active_branch.name
+        if branch_name in ("main", "master"):
+            print_info("Run `repr branch` to create a new feature branch")
+        else:
+            print_info("Run `repr commit` to generate message and commit, or `repr branch` to create a new feature branch")
+    except Exception:
+        print_info("Run `repr commit` to generate message and commit")
+
+
+@app.command("unstage")
+def unstage_files(
+    pattern: str = typer.Argument(..., help="File pattern to unstage (grep-style match)"),
+):
+    """
+    Unstage files matching pattern.
+
+    Examples:
+        repr unstage cli           # Unstage files containing "cli"
+        repr unstage .py           # Unstage files containing ".py"
+        repr unstage .             # Unstage all staged files
+    """
+    import subprocess
+    from .change_synthesis import get_repo, get_staged_changes
+
+    repo = get_repo(Path.cwd())
+    if not repo:
+        print_error("Not a git repository")
+        raise typer.Exit(1)
+
+    # Get currently staged files
+    staged = get_staged_changes(repo)
+    if not staged:
+        print_warning("No staged files")
+        raise typer.Exit(0)
+
+    # Special case: "." means all
+    if pattern == ".":
+        matching_files = [f.path for f in staged]
+    else:
+        # Grep-style regex match
+        import re
+        try:
+            regex = re.compile(pattern, re.IGNORECASE)
+        except re.error:
+            regex = re.compile(re.escape(pattern), re.IGNORECASE)
+        matching_files = [f.path for f in staged if regex.search(f.path)]
+
+    if not matching_files:
+        print_warning(f"No staged files matching '{pattern}'")
+        raise typer.Exit(0)
+
+    # Unstage matching files
+    try:
+        cmd = ["git", "restore", "--staged"] + matching_files
+        result = subprocess.run(cmd, cwd=repo.working_dir, capture_output=True, text=True)
+        if result.returncode != 0:
+            print_error(f"Failed to unstage files: {result.stderr}")
+            raise typer.Exit(1)
+    except Exception as e:
+        print_error(f"Failed to unstage files: {e}")
+        raise typer.Exit(1)
+
+    # Show what was unstaged
+    console.print(f"[bold]Unstaged {len(matching_files)} files[/]")
+    for f in matching_files:
+        console.print(f"  - {f}")
+
+
+@app.command("branch")
+def create_branch(
+    name: Optional[str] = typer.Argument(None, help="Branch name (optional, AI generates if omitted)"),
+    regenerate: bool = typer.Option(False, "--regenerate", "-r", help="Regenerate branch name"),
+):
+    """
+    Create and switch to a new branch.
+
+    If no name given, generates one from staged or unpushed changes.
+
+    Examples:
+        repr branch                    # AI generates name
+        repr branch feat/my-feature    # Use explicit name
+        repr branch -r                 # Regenerate name
+    """
+    import subprocess
+    from .change_synthesis import get_repo, get_staged_changes, get_unpushed_commits, format_file_changes, format_commit_changes
+
+    repo = get_repo(Path.cwd())
+    if not repo:
+        print_error("Not a git repository")
+        raise typer.Exit(1)
+
+    branch_name = name
+
+    if not branch_name:
+        # Check cache first
+        cached = _get_cached_commit_info()
+        if cached and cached.get("branch") and not regenerate:
+            branch_name = cached["branch"]
+            console.print(f"[{BRAND_MUTED}](cached)[/]")
+        else:
+            # Generate from staged or unpushed changes
+            staged = get_staged_changes(repo)
+            unpushed = get_unpushed_commits(repo)
+
+            if not staged and not unpushed:
+                print_error("No staged or unpushed changes to generate branch name from")
+                print_info("Run `repr add <pattern>` first, or provide a name")
+                raise typer.Exit(1)
+
+            from .openai_analysis import get_openai_client
+
+            client = get_openai_client()
+            if not client:
+                print_error("LLM not configured. Run `repr llm setup` first, or provide a name")
+                raise typer.Exit(1)
+
+            # Build context from staged and/or unpushed
+            changes_str = ""
+            if staged:
+                changes_str += "Staged changes:\n" + format_file_changes(staged) + "\n\n"
+            if unpushed:
+                changes_str += "Unpushed commits:\n" + format_commit_changes(unpushed)
+
+            prompt = COMMIT_MESSAGE_USER.format(changes=changes_str)
+
+            with create_spinner("Generating branch name..."):
+                response = asyncio.run(client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[
+                        {"role": "system", "content": COMMIT_MESSAGE_SYSTEM},
+                        {"role": "user", "content": prompt},
+                    ],
+                    response_format={"type": "json_object"},
+                    temperature=0.3,
+                ))
+                data = json.loads(response.choices[0].message.content)
+                branch_name = data.get("branch", "")
+                commit_msg = data.get("message", "")
+
+            # Cache both
+            _set_cached_commit_info(branch_name, commit_msg)
+
+    console.print(f"[bold]Branch:[/] {branch_name}")
+
+    try:
+        result = subprocess.run(
+            ["git", "checkout", "-b", branch_name],
+            cwd=repo.working_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            if "already exists" in result.stderr:
+                # Switch to existing branch
+                result = subprocess.run(
+                    ["git", "checkout", branch_name],
+                    cwd=repo.working_dir,
+                    capture_output=True,
+                    text=True,
+                )
+                if result.returncode == 0:
+                    print_success(f"Switched to {branch_name}")
+                    return
+            print_error(f"Failed: {result.stderr}")
+            raise typer.Exit(1)
+
+        print_success(f"Created and switched to {branch_name}")
+
+        # Check if there are staged changes and suggest next step
+        from .change_synthesis import get_staged_changes
+        staged = get_staged_changes(repo)
+        if staged:
+            print_info("Run `repr commit` to commit your staged changes")
+
+    except Exception as e:
+        print_error(f"Failed: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("commit")
+def commit_staged(
+    message: Optional[str] = typer.Option(None, "--message", "-m", help="Custom message (skip AI)"),
+    regenerate: bool = typer.Option(False, "--regenerate", "-r", help="Regenerate message"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation on main/master"),
+):
+    """
+    Generate commit message and commit staged changes.
+
+    Examples:
+        repr commit                    # Generate and commit
+        repr commit -m "fix: typo"     # Custom message
+        repr commit -r                 # Regenerate message
+    """
+    import subprocess
+    from .change_synthesis import get_repo, get_staged_changes, format_file_changes
+    from .config import get_config_value, set_config_value
+
+    repo = get_repo(Path.cwd())
+    if not repo:
+        print_error("Not a git repository")
+        raise typer.Exit(1)
+
+    # Check if on main/master
+    current_branch = subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=repo.working_dir,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+    if current_branch in ("main", "master") and not yes:
+        allow_main = get_config_value("allow_commit_to_main")
+        if allow_main is None:
+            # Ask user
+            print_warning(f"You're about to commit directly to {current_branch}")
+            console.print()
+            response = typer.prompt(
+                "Allow commits to main/master? [y]es / [n]o / [a]lways / [never]",
+                default="n",
+            ).lower()
+
+            if response in ("a", "always"):
+                set_config_value("allow_commit_to_main", True)
+                console.print(f"[{BRAND_MUTED}]Preference saved. Use `repr config set allow_commit_to_main false` to reset.[/]")
+            elif response in ("never",):
+                set_config_value("allow_commit_to_main", False)
+                console.print(f"[{BRAND_MUTED}]Preference saved. Use `repr config set allow_commit_to_main true` to reset.[/]")
+                print_info("Create a branch first: repr branch")
+                raise typer.Exit(0)
+            elif response not in ("y", "yes"):
+                print_info("Create a branch first: repr branch")
+                raise typer.Exit(0)
+        elif allow_main is False:
+            print_warning(f"Commits to {current_branch} are disabled")
+            print_info("Create a branch first: repr branch")
+            print_info("Or use: repr config set allow_commit_to_main true")
+            raise typer.Exit(0)
+
+    staged = get_staged_changes(repo)
+    if not staged:
+        print_warning("Nothing staged to commit")
+        print_info("Run `repr add <pattern>` first")
+        raise typer.Exit(0)
+
+    # Show staged files
+    console.print(f"[bold]Staged {len(staged)} files[/]")
+    for f in staged:
+        type_icon = {"A": "+", "M": "~", "D": "-", "R": "→"}.get(f.change_type, "?")
+        stats = ""
+        if f.insertions or f.deletions:
+            stats = f" [{BRAND_SUCCESS}]+{f.insertions}[/][{BRAND_ERROR}]-{f.deletions}[/]"
+        console.print(f"  {type_icon} {f.path}{stats}")
+    console.print()
+
+    # Get commit message
+    commit_msg = None
+
+    if message:
+        commit_msg = message
+    else:
+        # Check cache
+        cached = _get_cached_commit_info()
+        if cached and cached.get("message") and not regenerate:
+            commit_msg = cached["message"]
+            console.print(f"[{BRAND_MUTED}](cached)[/]")
+        else:
+            # Generate with LLM
+            from .openai_analysis import get_openai_client
+
+            client = get_openai_client()
+            if not client:
+                print_error("LLM not configured. Run `repr llm setup` first, or use -m")
+                raise typer.Exit(1)
+
+            changes_str = format_file_changes(staged)
+            prompt = COMMIT_MESSAGE_USER.format(changes=changes_str)
+
+            with create_spinner("Generating commit message..."):
+                response = asyncio.run(client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[
+                        {"role": "system", "content": COMMIT_MESSAGE_SYSTEM},
+                        {"role": "user", "content": prompt},
+                    ],
+                    response_format={"type": "json_object"},
+                    temperature=0.3,
+                ))
+                data = json.loads(response.choices[0].message.content)
+                branch_name = data.get("branch", "")
+                commit_msg = data.get("message", "")
+
+            _set_cached_commit_info(branch_name, commit_msg)
+
+    console.print(f"[bold]Message:[/] {commit_msg}")
+    console.print()
+
+    try:
+        result = subprocess.run(
+            ["git", "commit", "-m", commit_msg],
+            cwd=repo.working_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            print_error(f"Commit failed: {result.stderr}")
+            raise typer.Exit(1)
+
+        _clear_cached_commit_info()
+        print_success("Committed")
+
+        sha_result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=repo.working_dir,
+            capture_output=True,
+            text=True,
+        )
+        if sha_result.returncode == 0:
+            console.print(f"  [{BRAND_MUTED}]{sha_result.stdout.strip()}[/]")
+
+    except Exception as e:
+        print_error(f"Commit failed: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("push")
+def push_commits():
+    """
+    Push commits to remote.
+
+    Examples:
+        repr push
+    """
+    import subprocess
+    from .change_synthesis import get_repo
+
+    repo = get_repo(Path.cwd())
+    if not repo:
+        print_error("Not a git repository")
+        raise typer.Exit(1)
+
+    # Check for unpushed commits
+    try:
+        result = subprocess.run(
+            ["git", "log", "@{u}..", "--oneline"],
+            cwd=repo.working_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            # No upstream, just push
+            pass
+        elif not result.stdout.strip():
+            print_info("Nothing to push")
+            raise typer.Exit(0)
+        else:
+            commits = result.stdout.strip().split("\n")
+            console.print(f"[bold]Pushing {len(commits)} commits[/]")
+            for c in commits[:5]:
+                console.print(f"  [{BRAND_MUTED}]{c}[/]")
+            if len(commits) > 5:
+                console.print(f"  [{BRAND_MUTED}]... +{len(commits) - 5} more[/]")
+            console.print()
+    except Exception:
+        pass
+
+    try:
+        with create_spinner("Pushing..."):
+            result = subprocess.run(
+                ["git", "push"],
+                cwd=repo.working_dir,
+                capture_output=True,
+                text=True,
+            )
+        if result.returncode != 0:
+            if "no upstream branch" in result.stderr:
+                # Try push with -u
+                branch = subprocess.run(
+                    ["git", "branch", "--show-current"],
+                    cwd=repo.working_dir,
+                    capture_output=True,
+                    text=True,
+                ).stdout.strip()
+                with create_spinner(f"Setting upstream and pushing {branch}..."):
+                    result = subprocess.run(
+                        ["git", "push", "-u", "origin", branch],
+                        cwd=repo.working_dir,
+                        capture_output=True,
+                        text=True,
+                    )
+                if result.returncode != 0:
+                    print_error(f"Push failed: {result.stderr}")
+                    raise typer.Exit(1)
+            else:
+                print_error(f"Push failed: {result.stderr}")
+                raise typer.Exit(1)
+
+        print_success("Pushed")
+
+    except Exception as e:
+        print_error(f"Push failed: {e}")
+        raise typer.Exit(1)
+
+
+# ==================== SKILL COMMANDS ====================
+
+# Repr skill content for AI agents
+REPR_SKILL = '''---
+name: repr
+description: Use repr to extract developer context from git history for interviews, reviews, and AI agents
+---
+
+# repr - Developer Context Layer
+
+Use `repr` to capture and surface developer context from git history. Generate stories, prepare for interviews, create performance review material, and provide context to AI agents.
+
+## Quick Start
+
+```bash
+# Initialize (scan repos)
+repr init ~/code
+
+# Generate stories from recent commits
+repr generate --local
+
+# View generated stories
+repr stories
+repr story view <id>
+```
+
+## Common Commands
+
+| Command | Description |
+|---------|-------------|
+| `repr init <path>` | Scan and track repositories |
+| `repr generate --local` | Generate stories using local LLM |
+| `repr generate --days 30` | Generate from last 30 days |
+| `repr stories` | List all stories |
+| `repr story view <id>` | View a specific story |
+| `repr commits --days 7` | Show recent commits |
+| `repr dashboard` | Open web dashboard |
+| `repr mcp serve` | Start MCP server for AI agents |
+
+## Story Generation
+
+```bash
+# Generate with local LLM (Ollama)
+repr generate --local
+
+# Generate from specific timeframe
+repr generate --days 30 --local
+repr generate --since "2 weeks ago" --local
+
+# Generate interview stories (STAR format)
+repr generate --template interview --local
+```
+
+## LLM Configuration
+
+```bash
+# Configure local LLM
+repr llm configure
+
+# Add API keys (stored in OS keychain)
+repr llm add openai
+repr llm add anthropic
+
+# Test LLM connection
+repr llm test
+```
+
+## Use Cases
+
+- **Interview Prep**: Generate STAR-format stories from commits
+- **Performance Reviews**: Summarize months of work with impact
+- **Sprint Demos**: Quick changelogs for stakeholders
+- **AI Context**: MCP server provides work history to Claude/Cursor
+- **Weekly Reflection**: See what you accomplished
+
+## Privacy
+
+- Local-first: data stays in ~/.repr/
+- Air-gapped ready: works fully offline
+- BYOK: use your own API keys
+- Privacy audit: `repr privacy audit`
+'''
+
+
+def _get_skill_path(provider: str) -> Path:
+    """Get the skill installation path for a provider."""
+    home = Path.home()
+    if provider == "claude":
+        return home / ".claude" / "skills" / "repr"
+    elif provider == "gemini":
+        return home / ".gemini" / "skills" / "repr"
+    else:
+        raise ValueError(f"Unknown provider: {provider}")
+
+
+def _is_skill_installed(provider: str) -> bool:
+    """Check if skill is installed for a provider."""
+    skill_path = _get_skill_path(provider) / "SKILL.md"
+    return skill_path.exists()
+
+
+def _install_skill_to(provider: str) -> Path:
+    """Install the repr skill to a provider's skills directory."""
+    skill_dir = _get_skill_path(provider)
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    skill_file = skill_dir / "SKILL.md"
+    skill_file.write_text(REPR_SKILL)
+    return skill_dir
+
+
+@skill_app.callback(invoke_without_command=True)
+def skill_default(ctx: typer.Context):
+    """View the repr skill for AI agents."""
+    if ctx.invoked_subcommand is None:
+        # Show skill content
+        console.print()
+        console.print(f"[bold {BRAND_PRIMARY}]/repr[/] - [{BRAND_MUTED}]LLM instructions for using repr[/]")
+        console.print()
+
+        # Check installation status
+        claude_installed = _is_skill_installed("claude")
+        gemini_installed = _is_skill_installed("gemini")
+
+        if claude_installed or gemini_installed:
+            console.print(f"[{BRAND_SUCCESS}]Installed:[/]")
+            if claude_installed:
+                console.print(f"  [{BRAND_MUTED}]~/.claude/skills/repr/SKILL.md[/]")
+            if gemini_installed:
+                console.print(f"  [{BRAND_MUTED}]~/.gemini/skills/repr/SKILL.md[/]")
+            console.print()
+
+        console.print(f"[{BRAND_MUTED}]{'─' * 60}[/]")
+        console.print(REPR_SKILL)
+        console.print(f"[{BRAND_MUTED}]{'─' * 60}[/]")
+
+        if not claude_installed and not gemini_installed:
+            console.print(f"\n[{BRAND_MUTED}]Install with:[/] repr skill install")
+        console.print()
+
+
+@skill_app.command("install")
+def skill_install(
+    target: Optional[str] = typer.Argument(
+        None,
+        help="Target provider: claude, gemini, or all (default: all)",
+    ),
+):
+    """Install the repr skill to AI agent providers."""
+    console.print()
+    console.print(f"[bold {BRAND_PRIMARY}]Install repr skill[/]")
+    console.print()
+
+    if not target or target == "all":
+        installed = 0
+
+        # Try Claude
+        try:
+            dest = _install_skill_to("claude")
+            print_success(f"Installed to {dest}")
+            installed += 1
+        except Exception as e:
+            print_warning(f"Could not install to Claude: {e}")
+
+        # Try Gemini
+        try:
+            dest = _install_skill_to("gemini")
+            print_success(f"Installed to {dest}")
+            installed += 1
+        except Exception as e:
+            print_warning(f"Could not install to Gemini: {e}")
+
+        if installed == 0:
+            print_warning("No providers found.")
+        else:
+            console.print(f"\n[{BRAND_MUTED}]LLMs can now use /repr to learn how to run repr commands.[/]\n")
+
+    elif target in ("claude", "gemini"):
+        try:
+            dest = _install_skill_to(target)
+            print_success(f"Installed to {dest}")
+            console.print(f"\n[{BRAND_MUTED}]LLMs can now use /repr to learn how to run repr commands.[/]\n")
+        except Exception as e:
+            print_error(f"Installation failed: {e}")
+            raise typer.Exit(1)
+    else:
+        print_error(f"Unknown target: {target}")
+        console.print(f"[{BRAND_MUTED}]Usage: repr skill install [claude|gemini|all][/]")
+        raise typer.Exit(1)
+
+
+# PR generation prompts
+PR_SYSTEM = """You generate GitHub PR titles and descriptions. Given the commits, output JSON:
+
+{
+  "title": "<type>: <short description>",
+  "body": "## Summary\\n<bullet points>\\n\\n## Changes\\n<bullet points>"
+}
+
+Rules:
+- Title: under 72 chars, conventional commit style
+- Body: markdown, concise bullet points
+- Focus on what and why, not how
+
+Output only valid JSON."""
+
+PR_USER = """Generate PR title and description for these commits:
+
+{commits}"""
+
+
+@app.command("pr")
+def create_pr(
+    title: Optional[str] = typer.Option(None, "--title", "-t", help="Custom PR title"),
+    draft: bool = typer.Option(False, "--draft", "-d", help="Create as draft PR"),
+    regenerate: bool = typer.Option(False, "--regenerate", "-r", help="Regenerate title/body"),
+):
+    """
+    Create a pull request with AI-generated title and description.
+
+    Examples:
+        repr pr                    # AI generates title/body
+        repr pr -t "feat: add X"   # Custom title
+        repr pr --draft            # Create draft PR
+    """
+    import subprocess
+    from .change_synthesis import get_repo, get_unpushed_commits, format_commit_changes
+
+    repo = get_repo(Path.cwd())
+    if not repo:
+        print_error("Not a git repository")
+        raise typer.Exit(1)
+
+    # Check gh is installed
+    gh_check = subprocess.run(["which", "gh"], capture_output=True)
+    if gh_check.returncode != 0:
+        print_error("GitHub CLI (gh) not installed")
+        print_info("Install: brew install gh")
+        raise typer.Exit(1)
+
+    # Get current branch
+    current_branch = subprocess.run(
+        ["git", "branch", "--show-current"],
+        cwd=repo.working_dir,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+
+    if current_branch in ("main", "master"):
+        print_error(f"Cannot create PR from {current_branch}")
+        print_info("Create a branch first: repr branch")
+        raise typer.Exit(1)
+
+    # Check for unpushed commits
+    unpushed = get_unpushed_commits(repo)
+
+    # Get commits for this branch vs main/master
+    base_branch = "main"
+    check_main = subprocess.run(
+        ["git", "rev-parse", "--verify", "main"],
+        cwd=repo.working_dir,
+        capture_output=True,
+    )
+    if check_main.returncode != 0:
+        base_branch = "master"
+
+    log_result = subprocess.run(
+        ["git", "log", f"{base_branch}..HEAD", "--oneline"],
+        cwd=repo.working_dir,
+        capture_output=True,
+        text=True,
+    )
+    commits_text = log_result.stdout.strip()
+
+    if not commits_text:
+        print_warning("No commits to create PR from")
+        raise typer.Exit(0)
+
+    commits_list = commits_text.split("\n")
+    console.print(f"[bold]PR for {len(commits_list)} commits[/]")
+    for c in commits_list[:5]:
+        console.print(f"  [{BRAND_MUTED}]{c}[/]")
+    if len(commits_list) > 5:
+        console.print(f"  [{BRAND_MUTED}]... +{len(commits_list) - 5} more[/]")
+    console.print()
+
+    # Push if needed
+    if unpushed:
+        console.print(f"[{BRAND_MUTED}]Pushing {len(unpushed)} unpushed commits...[/]")
+        push_result = subprocess.run(
+            ["git", "push", "-u", "origin", current_branch],
+            cwd=repo.working_dir,
+            capture_output=True,
+            text=True,
+        )
+        if push_result.returncode != 0:
+            print_error(f"Push failed: {push_result.stderr}")
+            raise typer.Exit(1)
+
+    # Generate or use provided title/body
+    pr_title = title
+    pr_body = None
+
+    if not pr_title:
+        from .openai_analysis import get_openai_client
+
+        client = get_openai_client()
+        if not client:
+            print_error("LLM not configured. Run `repr llm setup` first, or use -t")
+            raise typer.Exit(1)
+
+        prompt = PR_USER.format(commits=commits_text)
+
+        with create_spinner("Generating PR..."):
+            response = asyncio.run(client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": PR_SYSTEM},
+                    {"role": "user", "content": prompt},
+                ],
+                response_format={"type": "json_object"},
+                temperature=0.3,
+            ))
+            data = json.loads(response.choices[0].message.content)
+            pr_title = data.get("title", current_branch)
+            pr_body = data.get("body", "")
+
+    console.print(f"[bold]Title:[/] {pr_title}")
+    if pr_body:
+        console.print(f"[bold]Body:[/]")
+        for line in pr_body.split("\n")[:5]:
+            console.print(f"  [{BRAND_MUTED}]{line}[/]")
+    console.print()
+
+    # Create PR
+    cmd = ["gh", "pr", "create", "--title", pr_title, "--base", base_branch]
+    if pr_body:
+        cmd.extend(["--body", pr_body])
+    if draft:
+        cmd.append("--draft")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=repo.working_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            print_error(f"PR creation failed: {result.stderr}")
+            raise typer.Exit(1)
+
+        pr_url = result.stdout.strip()
+        print_success("PR created")
+        console.print(f"  {pr_url}")
+
+    except Exception as e:
+        print_error(f"PR creation failed: {e}")
+        raise typer.Exit(1)
+
+
 # Entry point
 if __name__ == "__main__":
     app()