feat : updated pages

backend/Dockerfile

@@ -1,43 +1,28 @@
+# Backend Dockerfile
 FROM python:3.11-slim
 
-# Create a non-root user with UID 1000 (matches HF Spaces runtime)
-RUN useradd -m -u 1000 user
+# Set working directory
+WORKDIR /app
 
-# Set HOME and include user's local bin in PATH
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
-
-# Set working directory early to avoid permission issues
-WORKDIR $HOME/app
-
-# Install system dependencies as root
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
     gcc \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements first for better caching
-COPY requirements.txt /tmp/requirements.txt
-
-# Install Python dependencies (system-wide)
-RUN pip install --no-cache-dir -r /tmp/requirements.txt
-
-# Copy the application and set ownership to 'user' at copy time to avoid expensive chowns
-COPY --chown=user:user . $HOME/app
-
-# Ensure entrypoint is executable (no-op if missing)
-RUN chmod +x $HOME/app/entrypoint.sh || true
+COPY requirements.txt .
 
-# Create /data directory (runtime-mounted on HF Spaces) with safe permissions
-RUN mkdir -p /data && chmod 700 /data
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Switch to non-root user for subsequent steps and runtime
-USER user
+# Copy application code
+COPY . .
 
-# Upgrade pip in user's environment
-RUN pip install --no-cache-dir --upgrade pip
+# Create directory for database
+RUN mkdir -p /app/data
 
-# Expose the port and set entrypoint to prepare /data at runtime
-EXPOSE 7860
+# Expose port
+EXPOSE 8000
 
-ENTRYPOINT ["/home/user/app/entrypoint.sh"]
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

backend/app/agent_worker.py

@@ -0,0 +1,77 @@
+"""Background agent worker that autonomously completes tasks."""
+
+import asyncio
+import random
+from app.database import SessionLocal
+from app.models import Task, TaskStatus, Project, AI_AGENT_USER_ID
+from app.tools.memory import complete_task
+
+
+async def agent_loop():
+    """Background loop that processes tasks for agent-enabled projects."""
+    print("[Agent] Worker started, waiting for initial delay...")
+    # Initial delay to let the server start up
+    await asyncio.sleep(10)
+
+    while True:
+        try:
+            await process_one_task()
+        except Exception as e:
+            print(f"[Agent] Error: {e}")
+
+        # Wait 25-35 seconds (jitter to avoid rate limit patterns)
+        wait_time = random.uniform(25, 35)
+        await asyncio.sleep(wait_time)
+
+
+async def process_one_task():
+    """Pick a random todo task from agent-enabled projects and complete it."""
+    db = SessionLocal()
+    try:
+        # Find projects with agent enabled
+        projects = db.query(Project).filter(Project.agent_enabled == True).all()
+        if not projects:
+            return
+
+        # Pick random project
+        project = random.choice(projects)
+
+        # Find a random todo task
+        todo_tasks = db.query(Task).filter(
+            Task.project_id == project.id,
+            Task.status == TaskStatus.todo
+        ).all()
+
+        if not todo_tasks:
+            return
+
+        task = random.choice(todo_tasks)
+        print(f"[Agent] Starting task: {task.title}")
+
+        # Step 1: Move to in_progress
+        task.status = TaskStatus.in_progress
+        task.working_by = AI_AGENT_USER_ID
+        db.commit()
+
+        # Step 2: "Work" on it (small delay for realism)
+        await asyncio.sleep(random.uniform(2, 5))
+
+        # Step 3: Complete the task
+        result = await complete_task(
+            task_id=task.id,
+            project_id=project.id,
+            user_id=AI_AGENT_USER_ID,
+            what_i_did=f"Implemented {task.title}. {task.description or 'Completed the task as specified.'}",
+            actor_type="agent"
+        )
+
+        if result.get("success"):
+            print(f"[Agent] Completed task: {task.title}")
+        else:
+            print(f"[Agent] Failed to complete task: {result.get('error')}")
+
+    except Exception as e:
+        print(f"[Agent] Error in process_one_task: {e}")
+        db.rollback()
+    finally:
+        db.close()

backend/app/main.py

@@ -6,6 +6,7 @@ from fastapi.responses import JSONResponse
 from contextlib import asynccontextmanager
 from typing import List, Optional
 import os
+import asyncio
 from dotenv import load_dotenv
 
 from app import schemas
@@ -29,14 +30,39 @@ load_dotenv()
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Initialize database and vector store on startup."""
-    from app.database import init_db
+    from app.database import init_db, SessionLocal
     from app.vectorstore import init_vectorstore
-    
+    from app.models import User, AI_AGENT_USER_ID
+    from app.agent_worker import agent_loop
+
     init_db()
     init_vectorstore()
     print("[OK] Database and vector store initialized")
+
+    # Ensure AI Agent user exists
+    db = SessionLocal()
+    try:
+        if not db.query(User).filter(User.id == AI_AGENT_USER_ID).first():
+            db.add(User(id=AI_AGENT_USER_ID, first_name="AI", last_name="Agent"))
+            db.commit()
+            print("[OK] AI Agent user created")
+    finally:
+        db.close()
+
+    # Start agent worker in background
+    agent_task = asyncio.create_task(agent_loop())
+    print("[OK] Agent worker started")
+
     yield
 
+    # Cleanup on shutdown
+    agent_task.cancel()
+    try:
+        await agent_task
+    except asyncio.CancelledError:
+        pass
+    print("[OK] Agent worker stopped")
+
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -227,6 +253,81 @@ async def get_project_members(project_id: str):
         db.close()
 
 
+# ==================== Agent Endpoints ====================
+@app.post("/api/projects/{project_id}/agent/enable")
+async def enable_agent(project_id: str):
+    """Enable AI agent for this project. Adds agent to team."""
+    from app.database import get_db
+    from app.models import Project, ProjectMembership, AI_AGENT_USER_ID
+
+    db = next(get_db())
+    try:
+        # Check project exists
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+        # Enable agent
+        project.agent_enabled = True
+
+        # Add agent to project membership if not already
+        existing = db.query(ProjectMembership).filter(
+            ProjectMembership.project_id == project_id,
+            ProjectMembership.user_id == AI_AGENT_USER_ID
+        ).first()
+
+        if not existing:
+            membership = ProjectMembership(
+                project_id=project_id,
+                user_id=AI_AGENT_USER_ID,
+                role="agent"
+            )
+            db.add(membership)
+
+        db.commit()
+        return {"message": "AI Agent enabled", "project_id": project_id}
+    except HTTPException:
+        raise
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        db.close()
+
+
+@app.post("/api/projects/{project_id}/agent/disable")
+async def disable_agent(project_id: str):
+    """Disable AI agent for this project. Removes from team."""
+    from app.database import get_db
+    from app.models import Project, ProjectMembership, AI_AGENT_USER_ID
+
+    db = next(get_db())
+    try:
+        # Check project exists
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+        # Disable agent
+        project.agent_enabled = False
+
+        # Remove agent from project membership
+        db.query(ProjectMembership).filter(
+            ProjectMembership.project_id == project_id,
+            ProjectMembership.user_id == AI_AGENT_USER_ID
+        ).delete()
+
+        db.commit()
+        return {"message": "AI Agent disabled", "project_id": project_id}
+    except HTTPException:
+        raise
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        db.close()
+
+
 # ==================== Task Endpoints ====================
 @app.get("/api/projects/{project_id}/tasks")
 async def get_project_tasks(project_id: str, status: Optional[str] = None):
@@ -346,9 +447,17 @@ async def update_task_status(task_id: str, request: dict):
             raise HTTPException(status_code=404, detail="Task not found")
 
         new_status = request.get("status")
+        user_id = request.get("userId")  # Who is making this change
+
         if new_status not in ["todo", "in_progress", "done"]:
             raise HTTPException(status_code=400, detail="Invalid status. Must be: todo, in_progress, or done")
 
+        # Update working_by based on status
+        if new_status == "in_progress" and user_id:
+            task.working_by = user_id
+        elif new_status in ["todo", "done"]:
+            task.working_by = None  # Clear when not in progress
+
         task.status = TaskStatus(new_status)
         db.commit()
         db.refresh(task)
@@ -360,6 +469,7 @@ async def update_task_status(task_id: str, request: dict):
             "description": task.description,
             "status": task.status.value,
             "assigned_to": task.assigned_to,
+            "working_by": task.working_by,
             "created_at": task.created_at.isoformat() if task.created_at else None
         }
     except HTTPException:
@@ -539,6 +649,6 @@ if __name__ == "__main__":
     uvicorn.run(
         "app.main:app",
         host="0.0.0.0",
-        port=7860,
+        port=8000,
         reload=True
     )

backend/app/models.py

@@ -1,6 +1,6 @@
 """SQLAlchemy models for Project Memory."""
 
-from sqlalchemy import Column, String, DateTime, ForeignKey, Text, Enum, JSON
+from sqlalchemy import Column, String, DateTime, ForeignKey, Text, Enum, JSON, Boolean
 from sqlalchemy.orm import relationship
 from datetime import datetime
 import uuid
@@ -10,6 +10,10 @@ import random
 from app.database import Base
 
 
+# Special user ID for AI Agent
+AI_AGENT_USER_ID = "ai-agent"
+
+
 def generate_uuid() -> str:
     """Generate a new UUID string."""
     return str(uuid.uuid4())
@@ -80,7 +84,8 @@ class Project(Base):
     description = Column(Text, nullable=True)
     created_at = Column(DateTime, default=datetime.utcnow)
     created_by = Column(String, ForeignKey("users.id"), nullable=True)
-    
+    agent_enabled = Column(Boolean, default=False)  # Whether AI agent is enabled for this project
+
     # Relationships
     creator = relationship("User", back_populates="created_projects")
     memberships = relationship("ProjectMembership", back_populates="project")
@@ -113,6 +118,7 @@ class Task(Base):
     description = Column(Text, nullable=True)
     status = Column(Enum(TaskStatus), default=TaskStatus.todo)
     assigned_to = Column(String, nullable=True)  # userId or "agent"
+    working_by = Column(String, nullable=True)  # User ID currently working on this task
     created_at = Column(DateTime, default=datetime.utcnow)
     completed_at = Column(DateTime, nullable=True)
     

backend/app/smart_query.py

@@ -14,8 +14,21 @@ from typing import Optional
 import google.generativeai as genai
 import json
 import os
+import logging
 from dotenv import load_dotenv
 
+# Configure logging for smart_query
+logger = logging.getLogger("smart_query")
+logger.setLevel(logging.DEBUG)
+
+# Create console handler if not already present
+if not logger.handlers:
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.DEBUG)
+    formatter = logging.Formatter('[SmartQuery] %(asctime)s - %(levelname)s - %(message)s')
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+
 # Load environment variables
 load_dotenv()
 
@@ -99,7 +112,7 @@ GEMINI_TOOLS = [
             ),
             genai.protos.FunctionDeclaration(
                 name="list_tasks",
-                description="List tasks in the project, optionally filtered by status. Use this for queries like 'what tasks are done', 'pending tasks', 'all tasks'",
+                description="List tasks in the project, optionally filtered by status, who completed them, or completion date range. Use this for queries like 'what tasks are done', 'tasks completed by X', 'pending tasks', 'tasks completed in last 5 minutes'",
                 parameters=genai.protos.Schema(
                     type=genai.protos.Type.OBJECT,
                     properties={
@@ -107,9 +120,17 @@ GEMINI_TOOLS = [
                             type=genai.protos.Type.STRING,
                             description="Filter by status: 'todo', 'in_progress', 'done', or 'all' for no filter"
                         ),
-                        "assigned_to": genai.protos.Schema(
+                        "completed_by": genai.protos.Schema(
+                            type=genai.protos.Type.STRING,
+                            description="Filter by who completed the task - user name or user ID (e.g., 'sunny', 'John', 'ai-agent')"
+                        ),
+                        "completed_after": genai.protos.Schema(
+                            type=genai.protos.Type.STRING,
+                            description="Filter tasks completed after this datetime (ISO format)"
+                        ),
+                        "completed_before": genai.protos.Schema(
                             type=genai.protos.Type.STRING,
-                            description="Filter by assignee user ID or 'agent'"
+                            description="Filter tasks completed before this datetime (ISO format)"
                         ),
                         "limit": genai.protos.Schema(
                             type=genai.protos.Type.INTEGER,
@@ -141,6 +162,10 @@ async def smart_query(
     Returns:
         {answer: str, tools_used: list[str], sources: list[dict]}
     """
+    logger.info(f"=== NEW QUERY ===")
+    logger.info(f"Query: {query}")
+    logger.info(f"Project: {project_id}, User: {current_user_id}")
+
     # Parse datetime
     dt = datetime.fromisoformat(current_datetime) if current_datetime else datetime.now()
     context = QueryContext(current_user_id, dt, project_id)
@@ -169,7 +194,10 @@ RULES:
     try:
         # Get best available model from router for smart_query task
         model_name = model_router.get_model_for_task("smart_query")
+        logger.info(f"Selected model: {model_name}")
+
         if not model_name:
+            logger.warning("All models rate limited!")
             return {
                 "answer": "All models are rate limited. Please try again in a minute.",
                 "tools_used": [],
@@ -188,13 +216,15 @@ RULES:
 
         # Start chat and send query
         chat = model.start_chat()
+        logger.debug(f"Sending query to model...")
         response = chat.send_message(query)
 
         # Tool calling loop
         tool_results = []
         max_iterations = 5
+        iteration = 0
 
-        for _ in range(max_iterations):
+        for iteration in range(max_iterations):
             # Check for function calls in response
             function_calls = []
             for part in response.candidates[0].content.parts:
@@ -202,14 +232,30 @@ RULES:
                     function_calls.append(part.function_call)
 
             if not function_calls:
+                logger.debug(f"No more function calls after iteration {iteration}")
                 break  # No more function calls, we have final answer
 
+            logger.info(f"--- Iteration {iteration + 1}: {len(function_calls)} tool call(s) ---")
+
             # Execute each function call
             function_responses = []
             for fn_call in function_calls:
+                logger.info(f"  TOOL: {fn_call.name}")
+                logger.info(f"  ARGS: {json.dumps(dict(fn_call.args), default=str)}")
+
                 result = await execute_tool(fn_call.name, dict(fn_call.args), context)
                 tool_results.append({"tool": fn_call.name, "args": dict(fn_call.args), "result": result})
 
+                # Log result summary
+                if "error" in result:
+                    logger.error(f"  ERROR: {result['error']}")
+                elif "count" in result:
+                    logger.info(f"  RESULT: {result.get('count', 'N/A')} items returned")
+                elif "found" in result:
+                    logger.info(f"  RESULT: found={result['found']}")
+                else:
+                    logger.info(f"  RESULT: {list(result.keys())}")
+
                 function_responses.append(
                     genai.protos.Part(
                         function_response=genai.protos.FunctionResponse(
@@ -228,6 +274,10 @@ RULES:
             if hasattr(part, 'text'):
                 final_answer += part.text
 
+        logger.info(f"=== QUERY COMPLETE ===")
+        logger.info(f"Tools used: {[tr['tool'] for tr in tool_results]}")
+        logger.info(f"Answer preview: {final_answer[:200]}...")
+
         return {
             "answer": final_answer,
             "tools_used": [tr["tool"] for tr in tool_results],
@@ -235,6 +285,7 @@ RULES:
         }
 
     except Exception as e:
+        logger.error(f"Error processing query: {str(e)}", exc_info=True)
         return {
             "answer": f"Error processing query: {str(e)}",
             "tools_used": [],
@@ -284,35 +335,51 @@ def _get_recent_work_hint(db, user_id: str, project_id: str) -> str:
 
 def _resolve_user_in_project(db, project_id: str, user_name: str) -> dict:
     """
-    Resolve a user by name within project scope only using first/last name fields.
+    Resolve a user by ID or name within project scope.
+
+    First tries exact match by user ID (for cases like "ai-agent"),
+    then falls back to searching by first/last name.
 
     Returns:
         {"found": True, "user_id": "...", "user_name": "..."} - single match
         {"found": False, "reason": "not_found"} - no matches
         {"found": False, "reason": "ambiguous", "options": [...]} - multiple matches
     """
-    # Query users who are members of this project and match first or last name
+    from sqlalchemy import func, or_
+
+    # First try exact match by user ID (for cases like "ai-agent")
+    exact_match = db.query(User, ProjectMembership).join(
+        ProjectMembership, User.id == ProjectMembership.user_id
+    ).filter(
+        ProjectMembership.project_id == project_id,
+        User.id == user_name
+    ).first()
+
+    if exact_match:
+        user, membership = exact_match
+        return {
+            "found": True,
+            "user_id": str(user.id),
+            "user_name": f"{user.first_name} {user.last_name}"
+        }
+
+    # Fall back to searching by first_name, last_name, or concatenated full name
     matches = db.query(User, ProjectMembership).join(
         ProjectMembership, User.id == ProjectMembership.user_id
     ).filter(
         ProjectMembership.project_id == project_id,
-        User.name.ilike(f"%{user_name}%")
+        or_(
+            User.first_name.ilike(f"%{user_name}%"),
+            User.last_name.ilike(f"%{user_name}%"),
+            func.concat(User.first_name, ' ', User.last_name).ilike(f"%{user_name}%")
+        )
     ).all()
 
-    if not matches:
-        # Try first_name or last_name separately as fallback
-        matches = db.query(User, ProjectMembership).join(
-            ProjectMembership, User.id == ProjectMembership.user_id
-        ).filter(
-            ProjectMembership.project_id == project_id,
-            (User.first_name.ilike(f"%{user_name}%") | User.last_name.ilike(f"%{user_name}%"))
-        ).all()
-
     if not matches:
         return {
             "found": False,
             "reason": "not_found",
-            "message": f"No project member named '{user_name}' found"
+            "message": f"No project member with ID or name matching '{user_name}' found"
         }
 
     if len(matches) == 1:
@@ -568,13 +635,41 @@ def _tool_list_users(db, project_id: str) -> dict:
 
 
 def _tool_list_tasks(db, project_id: str, args: dict) -> dict:
-    """List tasks in project, optionally filtered by status."""
+    """List tasks in project, optionally filtered by status, who completed them, or date range."""
     from sqlalchemy import desc, func
 
     status_filter = args.get("status", "all")
-    assigned_to = args.get("assigned_to")
+    completed_by_name = args.get("completed_by")
+    completed_after = args.get("completed_after")
+    completed_before = args.get("completed_before")
     limit = args.get("limit", 20)
 
+    # Resolve completed_by user name/ID to user_id
+    completed_by_user_id = None
+    resolved_user_name = None
+    if completed_by_name:
+        resolution = _resolve_user_in_project(db, project_id, completed_by_name)
+        if not resolution["found"]:
+            return resolution  # Return not_found or ambiguous response
+        completed_by_user_id = resolution["user_id"]
+        resolved_user_name = resolution["user_name"]
+
+    # Parse date filters
+    date_after = None
+    date_before = None
+    if completed_after:
+        try:
+            date_str = completed_after.replace('Z', '+00:00').replace('+00:00', '')
+            date_after = datetime.fromisoformat(date_str)
+        except ValueError:
+            date_after = datetime.strptime(date_str[:10], '%Y-%m-%d')
+    if completed_before:
+        try:
+            date_str = completed_before.replace('Z', '+00:00').replace('+00:00', '')
+            date_before = datetime.fromisoformat(date_str)
+        except ValueError:
+            date_before = datetime.strptime(date_str[:10], '%Y-%m-%d') + timedelta(days=1)
+
     # Build base query - always filter by project_id
     base_query = db.query(Task).filter(Task.project_id == project_id)
 
@@ -586,9 +681,45 @@ def _tool_list_tasks(db, project_id: str, args: dict) -> dict:
         except ValueError:
             return {"error": f"Invalid status: {status_filter}. Use: todo, in_progress, done, or all"}
 
-    # Apply assignee filter
-    if assigned_to:
-        base_query = base_query.filter(Task.assigned_to == assigned_to)
+    # If filtering by completed_by or date range, find task_ids from LogEntry first
+    if completed_by_user_id or date_after or date_before:
+        # Build LogEntry query
+        log_query = db.query(LogEntry.task_id).filter(LogEntry.project_id == project_id)
+
+        if completed_by_user_id:
+            log_query = log_query.filter(LogEntry.user_id == completed_by_user_id)
+        if date_after:
+            log_query = log_query.filter(LogEntry.created_at >= date_after)
+        if date_before:
+            log_query = log_query.filter(LogEntry.created_at <= date_before)
+
+        # Get task_ids matching the filters
+        completed_task_ids = [log.task_id for log in log_query.all()]
+
+        if not completed_task_ids:
+            filter_desc = []
+            if resolved_user_name:
+                filter_desc.append(f"by {resolved_user_name}")
+            if date_after:
+                filter_desc.append(f"after {date_after.isoformat()}")
+            if date_before:
+                filter_desc.append(f"before {date_before.isoformat()}")
+
+            return {
+                "project_id": project_id,
+                "filter": {
+                    "status": status_filter,
+                    "completed_by": resolved_user_name,
+                    "completed_after": completed_after,
+                    "completed_before": completed_before
+                },
+                "total_count": 0,
+                "returned_count": 0,
+                "status_summary": {"todo": 0, "in_progress": 0, "done": 0},
+                "tasks": [],
+                "message": f"No tasks completed {' '.join(filter_desc)}"
+            }
+        base_query = base_query.filter(Task.id.in_(completed_task_ids))
 
     # Get TOTAL count before applying limit
     total_count = base_query.count()
@@ -602,11 +733,25 @@ def _tool_list_tasks(db, project_id: str, args: dict) -> dict:
     for task in all_tasks:
         status_counts[task.status.value] += 1
 
+    # Get completion info (who completed each task) from LogEntry
+    task_ids = [str(task.id) for task in tasks]
+    completion_logs = db.query(LogEntry).filter(LogEntry.task_id.in_(task_ids)).all()
+    completion_map = {}  # task_id -> {user_id, user_name, what_was_done}
+    for log in completion_logs:
+        user = db.query(User).filter(User.id == log.user_id).first() if log.user_id else None
+        completion_map[str(log.task_id)] = {
+            "completed_by_id": str(log.user_id) if log.user_id else None,
+            "completed_by_name": user.name if user else None,
+            "what_was_done": log.raw_input[:100] if log.raw_input else None
+        }
+
     return {
         "project_id": project_id,
         "filter": {
             "status": status_filter,
-            "assigned_to": assigned_to
+            "completed_by": resolved_user_name,
+            "completed_after": completed_after,
+            "completed_before": completed_before
         },
         "total_count": total_count,  # Actual total matching the filter
         "returned_count": len(tasks),  # How many in this response (may be limited)
@@ -619,7 +764,11 @@ def _tool_list_tasks(db, project_id: str, args: dict) -> dict:
                 "status": task.status.value,
                 "assigned_to": task.assigned_to,
                 "created_at": task.created_at.isoformat() if task.created_at else None,
-                "completed_at": task.completed_at.isoformat() if task.completed_at else None
+                "completed_at": task.completed_at.isoformat() if task.completed_at else None,
+                # Include completion details if available
+                "completed_by": completion_map.get(str(task.id), {}).get("completed_by_name"),
+                "completed_by_id": completion_map.get(str(task.id), {}).get("completed_by_id"),
+                "what_was_done": completion_map.get(str(task.id), {}).get("what_was_done")
             }
             for task in tasks
         ]

backend/app/tools/memory.py

@@ -58,6 +58,7 @@ async def complete_task(
     user_id: str,
     what_i_did: str,
     code_snippet: Optional[str] = None,
+    actor_type: str = "human",
     db: Optional[Session] = None
 ) -> dict:
     """
@@ -93,7 +94,7 @@ async def complete_task(
             project_id=project_id,
             task_id=task_id,
             user_id=user_id,
-            actor_type=ActorType.human,
+            actor_type=ActorType(actor_type),
             action_type=ActionType.task_completed,
             raw_input=what_i_did,
             code_snippet=code_snippet,

backend/app/tools/tasks.py

@@ -44,6 +44,7 @@ def create_task(project_id: str, title: str, description: str = None, assigned_t
             "description": task.description,
             "status": task.status.value,
             "assigned_to": task.assigned_to,
+            "working_by": task.working_by,
             "created_at": task.created_at.isoformat()
         }
     finally:
@@ -86,6 +87,7 @@ def list_tasks(project_id: str, status: str = None) -> dict:
                     "description": task.description,
                     "status": task.status.value,
                     "assigned_to": task.assigned_to,
+                    "working_by": task.working_by,
                     "created_at": task.created_at.isoformat(),
                     "completed_at": task.completed_at.isoformat() if task.completed_at else None
                 }

backend/entrypoint.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-set -e
-
-# Ensure /data exists and has safe permissions. On HF Spaces /data is mounted at runtime when
-# persistent storage is enabled. Creating it here is harmless for local runs.
-mkdir -p /data
-chmod 700 /data || true
-
-# Execute the command (or CMD) passed to the container
-exec "$@"

backend/tests/test_complete_api.py

@@ -4,7 +4,7 @@ import requests
 import json
 import sys
 
-BASE_URL = "http://localhost:7860"
+BASE_URL = "http://localhost:8000"
 
 print("="*60)
 print("PROJECT MEMORY - COMPLETE API TEST")

frontend/Dockerfile

@@ -26,7 +26,7 @@ COPY --from=builder /app/dist /usr/share/nginx/html
 COPY nginx.conf /etc/nginx/conf.d/default.conf
 
 # Expose port
-EXPOSE 7860
+EXPOSE 80
 
 # Start nginx
 CMD ["nginx", "-g", "daemon off;"]

frontend/nginx.conf

@@ -1,5 +1,5 @@
 server {
-    listen 7860;
+    listen 80;
     server_name localhost;
     
     root /usr/share/nginx/html;
@@ -12,7 +12,7 @@ server {
     
     # API proxy
     location /api {
-        proxy_pass http://backend:7860;
+        proxy_pass http://backend:8000;
         proxy_http_version 1.1;
         proxy_set_header Upgrade $http_upgrade;
         proxy_set_header Connection 'upgrade';
@@ -25,7 +25,7 @@ server {
     
     # WebSocket support (if needed)
     location /ws {
-        proxy_pass http://backend:7860;
+        proxy_pass http://backend:8000;
         proxy_http_version 1.1;
         proxy_set_header Upgrade $http_upgrade;
         proxy_set_header Connection "upgrade";

frontend/src/api/client.ts

@@ -1,6 +1,6 @@
 import type { User, UserCreate, Project, ProjectCreate, ProjectsResponse, ProjectAvailability, Task, TaskCreate, TasksResponse, MembersResponse, ActivityResponse } from '../types';
 
-const API_BASE = '/api';
+const API_BASE = 'http://localhost:8000/api';
 
 class ApiClient {
   private async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
@@ -86,10 +86,10 @@ class ApiClient {
     });
   }
 
-  async updateTaskStatus(taskId: string, status: 'todo' | 'in_progress' | 'done'): Promise<Task> {
+  async updateTaskStatus(taskId: string, status: 'todo' | 'in_progress' | 'done', userId?: string): Promise<Task> {
     return this.request<Task>(`/tasks/${taskId}/status`, {
       method: 'PATCH',
-      body: JSON.stringify({ status }),
+      body: JSON.stringify({ status, userId }),
     });
   }
 
@@ -98,6 +98,15 @@ class ApiClient {
     return this.request<MembersResponse>(`/projects/${projectId}/members`);
   }
 
+  // Agent Control
+  async enableAgent(projectId: string): Promise<{ message: string; project_id: string }> {
+    return this.request(`/projects/${projectId}/agent/enable`, { method: 'POST' });
+  }
+
+  async disableAgent(projectId: string): Promise<{ message: string; project_id: string }> {
+    return this.request(`/projects/${projectId}/agent/disable`, { method: 'POST' });
+  }
+
   // Search & Activity
   async searchProject(projectId: string, query: string, filters?: { userId?: string; dateFrom?: string; dateTo?: string }) {
     return this.request(`/projects/${projectId}/search`, {

frontend/src/pages/ActivityPage.tsx

@@ -38,6 +38,12 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
   const [showSuggestions, setShowSuggestions] = useState(false);
   const searchInputRef = useRef<HTMLInputElement>(null);
 
+  // Task generation state
+  const [isGeneratingTasks, setIsGeneratingTasks] = useState(false);
+
+  // Agent control state
+  const [isAgentLoading, setIsAgentLoading] = useState(false);
+
   const handleLogout = () => {
     clearProject();
     logout();
@@ -93,13 +99,40 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
     return () => document.removeEventListener('mousedown', handleClickOutside);
   }, []);
 
+  // Handle generating more tasks
+  const handleGenerateMoreTasks = async () => {
+    if (!currentProject) return;
+    setIsGeneratingTasks(true);
+    setError('');
+
+    try {
+      // Generate 10 tasks using AI
+      const { tasks: generatedTasks } = await api.generateTasks(currentProject.id, 10);
+
+      // Create all tasks in parallel
+      await Promise.all(
+        generatedTasks.map((t) =>
+          api.createTask(currentProject.id, { title: t.title, description: t.description })
+        )
+      );
+
+      // Refresh the task list
+      await fetchData(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to generate tasks');
+    } finally {
+      setIsGeneratingTasks(false);
+    }
+  };
+
   // Handle starting work on a task
   const handleStartWorking = async (task: Task) => {
+    if (!user) return;
     try {
-      // Update task status to in_progress if it's todo
+      // Update task status to in_progress if it's todo (pass user.id to track worker)
       if (task.status === 'todo') {
-        await api.updateTaskStatus(task.id, 'in_progress');
-        task = { ...task, status: 'in_progress' };
+        await api.updateTaskStatus(task.id, 'in_progress', user.id);
+        task = { ...task, status: 'in_progress', working_by: user.id };
       }
       // Navigate to task solver page
       onStartTask(task);
@@ -144,6 +177,45 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
       )
     : QUERY_SUGGESTIONS;
 
+  // Helper to get worker name from members list
+  const getWorkerName = (userId: string) => {
+    const member = members.find(m => m.id === userId);
+    return member ? member.firstName : userId;
+  };
+
+  // Handle adding AI agent to team
+  const handleAddAgent = async () => {
+    if (!currentProject) return;
+    setIsAgentLoading(true);
+    setError('');
+    try {
+      await api.enableAgent(currentProject.id);
+      await fetchData(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to add AI agent');
+    } finally {
+      setIsAgentLoading(false);
+    }
+  };
+
+  // Handle removing AI agent from team
+  const handleRemoveAgent = async () => {
+    if (!currentProject) return;
+    setIsAgentLoading(true);
+    setError('');
+    try {
+      await api.disableAgent(currentProject.id);
+      await fetchData(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to remove AI agent');
+    } finally {
+      setIsAgentLoading(false);
+    }
+  };
+
+  // Check if agent is in the team
+  const hasAgent = members.some(m => m.role === 'agent');
+
   if (!user || !currentProject) return null;
 
   // Group tasks by status
@@ -201,6 +273,68 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
           </div>
         )}
 
+        {/* Smart Query Search Bar - Outside grid for proper z-index */}
+        <div className="bg-white/5 backdrop-blur-lg rounded-xl p-4 border border-white/10 mb-6 relative z-10">
+          <form onSubmit={handleSearch} className="flex gap-2">
+            <div className="flex-1 relative" ref={searchInputRef}>
+              <input
+                type="text"
+                value={searchQuery}
+                onChange={(e) => setSearchQuery(e.target.value)}
+                onFocus={() => setShowSuggestions(true)}
+                placeholder="Ask anything about your project..."
+                className="w-full px-4 py-3 bg-white/5 border border-white/10 rounded-lg text-white placeholder-white/40 focus:outline-none focus:ring-2 focus:ring-purple-500"
+                disabled={isSearching}
+              />
+
+              {/* Suggestions Dropdown */}
+              {showSuggestions && !searchResult && filteredSuggestions.length > 0 && (
+                <div className="absolute top-full left-0 right-0 mt-2 bg-slate-800 border border-white/10 rounded-lg shadow-xl z-50 max-h-64 overflow-y-auto">
+                  <div className="p-2">
+                    <p className="text-purple-300/50 text-xs px-2 py-1 uppercase tracking-wide">Try asking...</p>
+                    {filteredSuggestions.map((suggestion, idx) => (
+                      <button
+                        key={idx}
+                        type="button"
+                        onClick={() => selectSuggestion(suggestion.text)}
+                        className="w-full text-left px-3 py-2 text-sm text-white hover:bg-white/10 rounded-lg transition-colors flex items-center justify-between group"
+                      >
+                        <span>{suggestion.text}</span>
+                        <span className="text-purple-400/50 text-xs group-hover:text-purple-400">{suggestion.category}</span>
+                      </button>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+            <button
+              type="submit"
+              disabled={isSearching || !searchQuery.trim()}
+              className="px-6 py-3 bg-purple-600 hover:bg-purple-700 disabled:bg-purple-800 disabled:cursor-not-allowed text-white font-medium rounded-lg transition-all"
+            >
+              {isSearching ? 'Asking...' : 'Ask'}
+            </button>
+          </form>
+
+          {/* Search Result */}
+          {searchResult && (
+            <div className="mt-4 p-4 bg-white/5 rounded-lg border border-purple-500/30">
+              <div className="flex items-start justify-between gap-4">
+                <div className="flex-1">
+                  <p className="text-purple-300 text-xs font-medium mb-2">AI Response:</p>
+                  <p className="text-white text-sm whitespace-pre-wrap">{searchResult.answer}</p>
+                </div>
+                <button
+                  onClick={clearSearch}
+                  className="text-purple-300/50 hover:text-white text-sm"
+                >
+                  Clear
+                </button>
+              </div>
+            </div>
+          )}
+        </div>
+
         {isLoading ? (
           <div className="flex items-center justify-center h-64">
             <div className="text-purple-300">Loading...</div>
@@ -208,69 +342,7 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
         ) : (
           <div className="grid lg:grid-cols-4 gap-6">
             {/* Main Content - Kanban Board (3 cols) */}
-            <div className="lg:col-span-3 space-y-6">
-              {/* Smart Query Search Bar */}
-              <div className="bg-white/5 backdrop-blur-lg rounded-xl p-4 border border-white/10">
-                <form onSubmit={handleSearch} className="flex gap-2">
-                  <div className="flex-1 relative" ref={searchInputRef}>
-                    <input
-                      type="text"
-                      value={searchQuery}
-                      onChange={(e) => setSearchQuery(e.target.value)}
-                      onFocus={() => setShowSuggestions(true)}
-                      placeholder="Ask anything about your project..."
-                      className="w-full px-4 py-3 bg-white/5 border border-white/10 rounded-lg text-white placeholder-white/40 focus:outline-none focus:ring-2 focus:ring-purple-500"
-                      disabled={isSearching}
-                    />
-
-                    {/* Suggestions Dropdown */}
-                    {showSuggestions && !searchResult && filteredSuggestions.length > 0 && (
-                      <div className="absolute top-full left-0 right-0 mt-2 bg-slate-800 border border-white/10 rounded-lg shadow-xl z-20 max-h-64 overflow-y-auto">
-                        <div className="p-2">
-                          <p className="text-purple-300/50 text-xs px-2 py-1 uppercase tracking-wide">Try asking...</p>
-                          {filteredSuggestions.map((suggestion, idx) => (
-                            <button
-                              key={idx}
-                              type="button"
-                              onClick={() => selectSuggestion(suggestion.text)}
-                              className="w-full text-left px-3 py-2 text-sm text-white hover:bg-white/10 rounded-lg transition-colors flex items-center justify-between group"
-                            >
-                              <span>{suggestion.text}</span>
-                              <span className="text-purple-400/50 text-xs group-hover:text-purple-400">{suggestion.category}</span>
-                            </button>
-                          ))}
-                        </div>
-                      </div>
-                    )}
-                  </div>
-                  <button
-                    type="submit"
-                    disabled={isSearching || !searchQuery.trim()}
-                    className="px-6 py-3 bg-purple-600 hover:bg-purple-700 disabled:bg-purple-800 disabled:cursor-not-allowed text-white font-medium rounded-lg transition-all"
-                  >
-                    {isSearching ? 'Asking...' : 'Ask'}
-                  </button>
-                </form>
-
-                {/* Search Result */}
-                {searchResult && (
-                  <div className="mt-4 p-4 bg-white/5 rounded-lg border border-purple-500/30">
-                    <div className="flex items-start justify-between gap-4">
-                      <div className="flex-1">
-                        <p className="text-purple-300 text-xs font-medium mb-2">AI Response:</p>
-                        <p className="text-white text-sm whitespace-pre-wrap">{searchResult.answer}</p>
-                      </div>
-                      <button
-                        onClick={clearSearch}
-                        className="text-purple-300/50 hover:text-white text-sm"
-                      >
-                        Clear
-                      </button>
-                    </div>
-                  </div>
-                )}
-              </div>
-
+            <div className="lg:col-span-3">
               {/* Kanban Board */}
               <div className="grid md:grid-cols-3 gap-4">
                 {/* Todo Column */}
@@ -302,6 +374,26 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
                     {todoTasks.length === 0 && (
                       <p className="text-purple-300/40 text-sm text-center py-4">No tasks</p>
                     )}
+                    {/* Generate More Tasks Button - shows when < 30 todos */}
+                    {todoTasks.length < 30 && (
+                      <button
+                        onClick={handleGenerateMoreTasks}
+                        disabled={isGeneratingTasks}
+                        className="mt-3 w-full px-3 py-2 bg-purple-500/20 hover:bg-purple-500/30 disabled:bg-purple-500/10 text-purple-300 disabled:text-purple-400/50 text-xs font-medium rounded border border-dashed border-purple-500/30 transition-all flex items-center justify-center gap-2"
+                      >
+                        {isGeneratingTasks ? (
+                          <>
+                            <svg className="w-3 h-3 animate-spin" fill="none" viewBox="0 0 24 24">
+                              <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
+                              <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                            </svg>
+                            Generating...
+                          </>
+                        ) : (
+                          <>+ Generate 10 More Tasks</>
+                        )}
+                      </button>
+                    )}
                   </div>
                 </div>
 
@@ -314,23 +406,43 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
                     </h3>
                   </div>
                   <div className="p-3 space-y-2 max-h-[60vh] overflow-y-auto">
-                    {inProgressTasks.map((task) => (
-                      <div
-                        key={task.id}
-                        className="bg-white/5 rounded-lg p-3 border border-white/5"
-                      >
-                        <h4 className="text-white text-sm font-medium truncate">{task.title}</h4>
-                        {task.description && (
-                          <p className="text-purple-300/60 text-xs mt-1 line-clamp-2">{task.description}</p>
-                        )}
-                        <button
-                          onClick={() => handleStartWorking(task)}
-                          className="mt-2 w-full px-3 py-1.5 bg-blue-500/20 hover:bg-blue-500/30 text-blue-300 text-xs font-medium rounded transition-all"
+                    {inProgressTasks.map((task) => {
+                      const isOtherUserWorking = task.working_by && task.working_by !== user.id;
+                      const isCurrentUserWorking = task.working_by === user.id;
+
+                      return (
+                        <div
+                          key={task.id}
+                          className="bg-white/5 rounded-lg p-3 border border-white/5"
                         >
-                          Continue Working
-                        </button>
-                      </div>
-                    ))}
+                          <h4 className="text-white text-sm font-medium truncate">{task.title}</h4>
+                          {task.description && (
+                            <p className="text-purple-300/60 text-xs mt-1 line-clamp-2">{task.description}</p>
+                          )}
+                          {/* Show who is working on this task */}
+                          {task.working_by && (
+                            <p className="text-blue-300 text-xs mt-1">
+                              {isCurrentUserWorking ? 'You are' : `${getWorkerName(task.working_by)} is`} working
+                            </p>
+                          )}
+                          {isOtherUserWorking ? (
+                            <button
+                              disabled
+                              className="mt-2 w-full px-3 py-1.5 bg-gray-500/20 text-gray-400 text-xs font-medium rounded cursor-not-allowed"
+                            >
+                              {getWorkerName(task.working_by)} is working
+                            </button>
+                          ) : (
+                            <button
+                              onClick={() => handleStartWorking(task)}
+                              className="mt-2 w-full px-3 py-1.5 bg-blue-500/20 hover:bg-blue-500/30 text-blue-300 text-xs font-medium rounded transition-all"
+                            >
+                              Continue Working
+                            </button>
+                          )}
+                        </div>
+                      );
+                    })}
                     {inProgressTasks.length === 0 && (
                       <p className="text-purple-300/40 text-sm text-center py-4">No tasks</p>
                     )}
@@ -375,17 +487,55 @@ export function ActivityPage({ onStartTask }: ActivityPageProps) {
                 <div className="p-3 space-y-2 max-h-48 overflow-y-auto">
                   {members.map((member) => (
                     <div key={member.id} className="flex items-center gap-3">
-                      <div className="w-8 h-8 rounded-full bg-purple-600 flex items-center justify-center text-white text-xs font-medium">
-                        {member.firstName[0]}{member.lastName[0]}
-                      </div>
+                      {member.role === 'agent' ? (
+                        <div className="w-8 h-8 rounded-full bg-cyan-600 flex items-center justify-center text-sm">
+                          🤖
+                        </div>
+                      ) : (
+                        <div className="w-8 h-8 rounded-full bg-purple-600 flex items-center justify-center text-white text-xs font-medium">
+                          {member.firstName[0]}{member.lastName[0]}
+                        </div>
+                      )}
                       <div className="flex-1 min-w-0">
                         <p className="text-white text-sm truncate">
                           {member.firstName} {member.lastName}
                         </p>
-                        <p className="text-purple-300/50 text-xs">{member.role}</p>
+                        <p className={`text-xs ${member.role === 'agent' ? 'text-cyan-300/50' : 'text-purple-300/50'}`}>
+                          {member.role}
+                        </p>
                       </div>
+                      {member.role === 'agent' && currentProject.role === 'owner' && (
+                        <button
+                          onClick={handleRemoveAgent}
+                          disabled={isAgentLoading}
+                          className="text-red-400/70 hover:text-red-400 text-xs disabled:opacity-50"
+                        >
+                          Remove
+                        </button>
+                      )}
                     </div>
                   ))}
+
+                  {/* Add AI Agent Button - only if no agent and user is owner */}
+                  {!hasAgent && currentProject.role === 'owner' && (
+                    <button
+                      onClick={handleAddAgent}
+                      disabled={isAgentLoading}
+                      className="mt-2 w-full px-3 py-2 bg-cyan-500/20 hover:bg-cyan-500/30 disabled:bg-cyan-500/10 text-cyan-300 disabled:text-cyan-400/50 text-xs font-medium rounded border border-dashed border-cyan-500/30 transition-all flex items-center justify-center gap-2"
+                    >
+                      {isAgentLoading ? (
+                        <>
+                          <svg className="w-3 h-3 animate-spin" fill="none" viewBox="0 0 24 24">
+                            <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
+                            <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                          </svg>
+                          Adding...
+                        </>
+                      ) : (
+                        <>🤖 Add AI Agent</>
+                      )}
+                    </button>
+                  )}
                 </div>
               </div>
 

frontend/src/types/index.ts

@@ -37,6 +37,7 @@ export interface Task {
   description: string;
   status: 'todo' | 'in_progress' | 'done';
   assigned_to?: string;
+  working_by?: string;  // User ID currently working on this task
   created_at: string;
 }
 
@@ -52,7 +53,7 @@ export interface ProjectMember {
   firstName: string;
   lastName: string;
   avatar_url?: string;
-  role: 'owner' | 'member';
+  role: 'owner' | 'member' | 'agent';
   joined_at: string;
 }