kin/web/api.py

"""
Kin Web API — FastAPI backend reading ~/.kin/kin.db via core.models.
Run: uvicorn web.api:app --reload --port 8420
"""

import glob as _glob
import logging
import mimetypes
import shutil
import subprocess
import sys
from pathlib import Path

# Ensure project root on sys.path
sys.path.insert(0, str(Path(__file__).parent.parent))

from fastapi import FastAPI, File, HTTPException, Query, UploadFile
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse, FileResponse, Response
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel, model_validator

from core.db import init_db
from core import models
from core.models import VALID_COMPLETION_MODES, TASK_CATEGORIES
from agents.bootstrap import (
    detect_tech_stack, detect_modules, extract_decisions_from_claude_md,
    find_vault_root, scan_obsidian, save_to_db,
)

DB_PATH = Path.home() / ".kin" / "kin.db"

_logger = logging.getLogger("kin")

# ---------------------------------------------------------------------------
# Startup: verify claude CLI is available in PATH
# ---------------------------------------------------------------------------

def _check_claude_available() -> None:
    """Warn at startup if claude CLI cannot be found in PATH.

    launchctl daemons run with a stripped environment and may not see
    /opt/homebrew/bin where claude is typically installed.
    See Decision #28.
    """
    from agents.runner import _build_claude_env  # avoid circular import at module level
    env = _build_claude_env()
    claude_path = shutil.which("claude", path=env["PATH"])
    if claude_path:
        _logger.info("claude CLI found: %s", claude_path)
    else:
        _logger.warning(
            "WARNING: claude CLI not found in PATH (%s). "
            "Agent pipelines will fail with returncode 127. "
            "Fix: add /opt/homebrew/bin to EnvironmentVariables.PATH in "
            "~/Library/LaunchAgents/com.kin.api.plist and reload with: "
            "launchctl unload ~/Library/LaunchAgents/com.kin.api.plist && "
            "launchctl load ~/Library/LaunchAgents/com.kin.api.plist",
            env.get("PATH", ""),
        )


def _check_git_available() -> None:
    """Warn at startup if git cannot be found in PATH.

    launchctl daemons run with a stripped environment and may not see
    git in the standard directories. See Decision #28.
    """
    from agents.runner import _build_claude_env  # avoid circular import at module level
    env = _build_claude_env()
    git_path = shutil.which("git", path=env["PATH"])
    if git_path:
        _logger.info("git found: %s", git_path)
    else:
        _logger.warning(
            "WARNING: git not found in PATH (%s). "
            "Autocommit will fail silently. "
            "Fix: add git directory to EnvironmentVariables.PATH in "
            "~/Library/LaunchAgents/com.kin.api.plist and reload with: "
            "launchctl unload ~/Library/LaunchAgents/com.kin.api.plist && "
            "launchctl load ~/Library/LaunchAgents/com.kin.api.plist",
            env.get("PATH", ""),
        )


_check_claude_available()
_check_git_available()

app = FastAPI(title="Kin API", version="0.1.0")

# Start pipeline watchdog (KIN-099): detects dead subprocess PIDs every 30s
from core.watchdog import start_watchdog as _start_watchdog
_start_watchdog(DB_PATH)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)


def get_conn():
    return init_db(DB_PATH)


def _launch_pipeline_subprocess(task_id: str) -> None:
    """Spawn `cli.main run {task_id}` in a detached background subprocess.

    Used by auto-trigger (label 'auto') and revise endpoint.
    Never raises — subprocess errors are logged only.
    """
    import os
    kin_root = Path(__file__).parent.parent
    cmd = [sys.executable, "-m", "cli.main", "--db", str(DB_PATH), "run", task_id]
    cmd.append("--allow-write")
    env = os.environ.copy()
    if 'SSH_AUTH_SOCK' not in env:
        _socks = _glob.glob('/private/tmp/com.apple.launchd.*/Listeners')
        if _socks:
            env['SSH_AUTH_SOCK'] = _socks[0]
    env["KIN_NONINTERACTIVE"] = "1"
    try:
        proc = subprocess.Popen(
            cmd,
            cwd=str(kin_root),
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            stdin=subprocess.DEVNULL,
            env=env,
        )
        _logger.info("Auto-triggered pipeline for %s, pid=%d", task_id, proc.pid)
    except Exception as exc:
        _logger.warning("Failed to launch pipeline for %s: %s", task_id, exc)


# ---------------------------------------------------------------------------
# Projects
# ---------------------------------------------------------------------------

@app.get("/api/projects")
def list_projects(status: str | None = None):
    conn = get_conn()
    summary = models.get_project_summary(conn)
    if status:
        summary = [s for s in summary if s["status"] == status]
    conn.close()
    return summary


class NewProjectCreate(BaseModel):
    id: str
    name: str
    path: str | None = None
    description: str
    roles: list[str]
    tech_stack: list[str] | None = None
    priority: int = 5
    language: str = "ru"


@app.post("/api/projects/new")
def new_project_with_phases(body: NewProjectCreate):
    """Create project + sequential research phases (KIN-059)."""
    from core.phases import create_project_with_phases, validate_roles
    clean_roles = validate_roles(body.roles)
    if not clean_roles:
        raise HTTPException(400, "At least one research role must be selected (excluding architect)")
    conn = get_conn()
    if models.get_project(conn, body.id):
        conn.close()
        raise HTTPException(409, f"Project '{body.id}' already exists")
    try:
        result = create_project_with_phases(
            conn, body.id, body.name, body.path,
            description=body.description,
            selected_roles=clean_roles,
            tech_stack=body.tech_stack,
            priority=body.priority,
            language=body.language,
        )
    except ValueError as e:
        conn.close()
        raise HTTPException(400, str(e))
    conn.close()
    return result


@app.get("/api/projects/{project_id}")
def get_project(project_id: str):
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    tasks = models.list_tasks(conn, project_id=project_id)
    mods = models.get_modules(conn, project_id)
    decisions = models.get_decisions(conn, project_id)
    conn.close()
    return {**p, "tasks": tasks, "modules": mods, "decisions": decisions}


VALID_PROJECT_TYPES = {"development", "operations", "research"}


class ProjectCreate(BaseModel):
    id: str
    name: str
    path: str | None = None
    tech_stack: list[str] | None = None
    status: str = "active"
    priority: int = 5
    project_type: str = "development"
    ssh_host: str | None = None
    ssh_user: str | None = None
    ssh_key_path: str | None = None
    ssh_proxy_jump: str | None = None
    test_command: str = 'make test'

    @model_validator(mode="after")
    def validate_fields(self) -> "ProjectCreate":
        if self.project_type == "operations" and not self.ssh_host:
            raise ValueError("ssh_host is required for operations projects")
        if self.project_type != "operations" and not self.path:
            raise ValueError("path is required for non-operations projects")
        return self


class ProjectPatch(BaseModel):
    execution_mode: str | None = None
    autocommit_enabled: bool | None = None
    auto_test_enabled: bool | None = None
    obsidian_vault_path: str | None = None
    deploy_command: str | None = None
    test_command: str | None = None
    project_type: str | None = None
    ssh_host: str | None = None
    ssh_user: str | None = None
    ssh_key_path: str | None = None
    ssh_proxy_jump: str | None = None


@app.patch("/api/projects/{project_id}")
def patch_project(project_id: str, body: ProjectPatch):
    has_any = any([
        body.execution_mode, body.autocommit_enabled is not None,
        body.auto_test_enabled is not None,
        body.obsidian_vault_path, body.deploy_command is not None,
        body.test_command is not None,
        body.project_type, body.ssh_host is not None,
        body.ssh_user is not None, body.ssh_key_path is not None,
        body.ssh_proxy_jump is not None,
    ])
    if not has_any:
        raise HTTPException(400, "Nothing to update.")
    if body.execution_mode is not None and body.execution_mode not in VALID_EXECUTION_MODES:
        raise HTTPException(400, f"Invalid execution_mode '{body.execution_mode}'. Must be one of: {', '.join(VALID_EXECUTION_MODES)}")
    if body.project_type is not None and body.project_type not in VALID_PROJECT_TYPES:
        raise HTTPException(400, f"Invalid project_type '{body.project_type}'. Must be one of: {', '.join(VALID_PROJECT_TYPES)}")
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    fields = {}
    if body.execution_mode is not None:
        fields["execution_mode"] = body.execution_mode
    if body.autocommit_enabled is not None:
        fields["autocommit_enabled"] = int(body.autocommit_enabled)
    if body.auto_test_enabled is not None:
        fields["auto_test_enabled"] = int(body.auto_test_enabled)
    if body.obsidian_vault_path is not None:
        fields["obsidian_vault_path"] = body.obsidian_vault_path
    if body.deploy_command is not None:
        # Empty string = sentinel for clearing (decision #68)
        fields["deploy_command"] = None if body.deploy_command == "" else body.deploy_command
    if body.test_command is not None:
        fields["test_command"] = body.test_command
    if body.project_type is not None:
        fields["project_type"] = body.project_type
    if body.ssh_host is not None:
        fields["ssh_host"] = body.ssh_host
    if body.ssh_user is not None:
        fields["ssh_user"] = body.ssh_user
    if body.ssh_key_path is not None:
        fields["ssh_key_path"] = body.ssh_key_path
    if body.ssh_proxy_jump is not None:
        fields["ssh_proxy_jump"] = body.ssh_proxy_jump
    models.update_project(conn, project_id, **fields)
    p = models.get_project(conn, project_id)
    conn.close()
    return p


@app.delete("/api/projects/{project_id}", status_code=204)
def delete_project(project_id: str):
    """Delete a project and all its related data (tasks, decisions, phases, logs)."""
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    models.delete_project(conn, project_id)
    conn.close()
    return Response(status_code=204)


@app.post("/api/projects/{project_id}/sync/obsidian")
def sync_obsidian_endpoint(project_id: str):
    """Запускает двусторонний Obsidian sync для проекта."""
    from core.obsidian_sync import sync_obsidian

    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    if not p.get("obsidian_vault_path"):
        conn.close()
        raise HTTPException(400, "obsidian_vault_path not set for this project")
    result = sync_obsidian(conn, project_id)
    conn.close()
    return result


@app.post("/api/projects/{project_id}/deploy")
def deploy_project(project_id: str):
    """Execute deploy_command for a project. Returns stdout/stderr/exit_code.

    # WARNING: shell=True — deploy_command is admin-only, set in Settings by the project owner.
    """
    import time
    conn = get_conn()
    p = models.get_project(conn, project_id)
    conn.close()
    if not p:
        raise HTTPException(404, f"Project '{project_id}' not found")
    deploy_command = p.get("deploy_command")
    if not deploy_command:
        raise HTTPException(400, "deploy_command not set for this project")
    cwd = p.get("path") or None
    start = time.monotonic()
    try:
        result = subprocess.run(
            deploy_command,
            shell=True,  # WARNING: shell=True — command is admin-only
            cwd=cwd,
            capture_output=True,
            text=True,
            timeout=60,
        )
    except subprocess.TimeoutExpired:
        raise HTTPException(504, "Deploy command timed out after 60 seconds")
    except Exception as e:
        raise HTTPException(500, f"Deploy failed: {e}")
    duration = round(time.monotonic() - start, 2)
    return {
        "success": result.returncode == 0,
        "exit_code": result.returncode,
        "stdout": result.stdout,
        "stderr": result.stderr,
        "duration_seconds": duration,
    }


@app.post("/api/projects")
def create_project(body: ProjectCreate):
    if body.project_type not in VALID_PROJECT_TYPES:
        raise HTTPException(400, f"Invalid project_type '{body.project_type}'. Must be one of: {', '.join(VALID_PROJECT_TYPES)}")
    conn = get_conn()
    if models.get_project(conn, body.id):
        conn.close()
        raise HTTPException(409, f"Project '{body.id}' already exists")
    p = models.create_project(
        conn, body.id, body.name, body.path,
        tech_stack=body.tech_stack, status=body.status, priority=body.priority,
        project_type=body.project_type,
        ssh_host=body.ssh_host,
        ssh_user=body.ssh_user,
        ssh_key_path=body.ssh_key_path,
        ssh_proxy_jump=body.ssh_proxy_jump,
    )
    if body.test_command != "make test":
        p = models.update_project(conn, body.id, test_command=body.test_command)
    conn.close()
    return p


# ---------------------------------------------------------------------------
# Phases (KIN-059)
# ---------------------------------------------------------------------------

@app.get("/api/projects/{project_id}/phases")
def get_project_phases(project_id: str):
    """List research phases for a project, with task data joined."""
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    phases = models.list_phases(conn, project_id)
    result = []
    for phase in phases:
        task = models.get_task(conn, phase["task_id"]) if phase.get("task_id") else None
        result.append({**phase, "task": task})
    conn.close()
    return result


class PhaseApprove(BaseModel):
    comment: str | None = None


class PhaseReject(BaseModel):
    reason: str


class PhaseRevise(BaseModel):
    comment: str


@app.post("/api/phases/{phase_id}/approve")
def approve_phase(phase_id: int, body: PhaseApprove | None = None):
    """Approve a research phase and activate the next one."""
    from core.phases import approve_phase as _approve
    conn = get_conn()
    phase = models.get_phase(conn, phase_id)
    if not phase:
        conn.close()
        raise HTTPException(404, f"Phase {phase_id} not found")
    try:
        result = _approve(conn, phase_id)
    except ValueError as e:
        conn.close()
        raise HTTPException(400, str(e))
    # Mark the phase's task as done for consistency
    if phase.get("task_id"):
        models.update_task(conn, phase["task_id"], status="done")
    conn.close()
    return result


@app.post("/api/phases/{phase_id}/reject")
def reject_phase(phase_id: int, body: PhaseReject):
    """Reject a research phase."""
    from core.phases import reject_phase as _reject
    conn = get_conn()
    phase = models.get_phase(conn, phase_id)
    if not phase:
        conn.close()
        raise HTTPException(404, f"Phase {phase_id} not found")
    try:
        result = _reject(conn, phase_id, body.reason)
    except ValueError as e:
        conn.close()
        raise HTTPException(400, str(e))
    conn.close()
    return result


@app.post("/api/phases/{phase_id}/revise")
def revise_phase(phase_id: int, body: PhaseRevise):
    """Request revision for a research phase."""
    from core.phases import revise_phase as _revise
    if not body.comment.strip():
        raise HTTPException(400, "comment is required")
    conn = get_conn()
    phase = models.get_phase(conn, phase_id)
    if not phase:
        conn.close()
        raise HTTPException(404, f"Phase {phase_id} not found")
    try:
        result = _revise(conn, phase_id, body.comment)
    except ValueError as e:
        conn.close()
        raise HTTPException(400, str(e))
    conn.close()
    return result


@app.post("/api/projects/{project_id}/phases/start")
def start_project_phase(project_id: str):
    """Launch agent for the current active/revising phase in background. Returns 202.

    Finds the first phase with status 'active' or 'revising', sets its task to
    in_progress, spawns a background subprocess (same as /api/tasks/{id}/run),
    and returns immediately so the HTTP request doesn't block on agent execution.
    """
    from agents.runner import check_claude_auth, ClaudeAuthError
    try:
        check_claude_auth()
    except ClaudeAuthError:
        raise HTTPException(503, detail={
            "error": "claude_auth_required",
            "message": "Claude CLI requires login",
            "instructions": "Run: claude login",
        })

    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")

    phases = models.list_phases(conn, project_id)
    active_phase = next(
        (ph for ph in phases if ph["status"] in ("active", "revising")), None
    )
    if not active_phase:
        conn.close()
        raise HTTPException(404, f"No active or revising phase for project '{project_id}'")

    task_id = active_phase.get("task_id")
    if not task_id:
        conn.close()
        raise HTTPException(400, f"Phase {active_phase['id']} has no task assigned")

    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")

    models.update_task(conn, task_id, status="in_progress")
    conn.close()

    kin_root = Path(__file__).parent.parent
    cmd = [sys.executable, "-m", "cli.main", "--db", str(DB_PATH),
           "run", task_id]
    cmd.append("--allow-write")  # always required: subprocess runs non-interactively (stdin=DEVNULL)

    import os
    env = os.environ.copy()
    env["KIN_NONINTERACTIVE"] = "1"

    try:
        proc = subprocess.Popen(
            cmd,
            cwd=str(kin_root),
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            stdin=subprocess.DEVNULL,
            env=env,
        )
        _logger.info("Phase agent started for task %s (phase %d), pid=%d",
                     task_id, active_phase["id"], proc.pid)
    except Exception as e:
        raise HTTPException(500, f"Failed to start phase agent: {e}")

    return JSONResponse(
        {"status": "started", "phase_id": active_phase["id"], "task_id": task_id},
        status_code=202,
    )


# ---------------------------------------------------------------------------
# Tasks
# ---------------------------------------------------------------------------

@app.get("/api/tasks/{task_id}")
def get_task(task_id: str):
    conn = get_conn()
    t = models.get_task(conn, task_id)
    conn.close()
    if not t:
        raise HTTPException(404, f"Task '{task_id}' not found")
    return t


class TaskCreate(BaseModel):
    project_id: str
    title: str
    priority: int = 5
    route_type: str | None = None
    category: str | None = None
    acceptance_criteria: str | None = None
    labels: list[str] | None = None


@app.post("/api/tasks")
def create_task(body: TaskCreate):
    conn = get_conn()
    p = models.get_project(conn, body.project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{body.project_id}' not found")
    category = None
    if body.category:
        category = body.category.upper()
        if category not in TASK_CATEGORIES:
            conn.close()
            raise HTTPException(400, f"Invalid category '{category}'. Must be one of: {', '.join(TASK_CATEGORIES)}")
    task_id = models.next_task_id(conn, body.project_id, category=category)
    brief = {"route_type": body.route_type} if body.route_type else None
    t = models.create_task(conn, task_id, body.project_id, body.title,
                           priority=body.priority, brief=brief, category=category,
                           acceptance_criteria=body.acceptance_criteria,
                           labels=body.labels)
    conn.close()

    # Auto-trigger: if task has 'auto' label, launch pipeline in background
    if body.labels and "auto" in body.labels:
        _launch_pipeline_subprocess(task_id)

    return t


VALID_ROUTE_TYPES = {"debug", "feature", "refactor", "hotfix"}


class TaskPatch(BaseModel):
    status: str | None = None
    execution_mode: str | None = None
    priority: int | None = None
    route_type: str | None = None
    title: str | None = None
    brief_text: str | None = None
    acceptance_criteria: str | None = None


VALID_STATUSES = set(models.VALID_TASK_STATUSES)
VALID_EXECUTION_MODES = VALID_COMPLETION_MODES


@app.patch("/api/tasks/{task_id}")
def patch_task(task_id: str, body: TaskPatch):
    if body.status is not None and body.status not in VALID_STATUSES:
        raise HTTPException(400, f"Invalid status '{body.status}'. Must be one of: {', '.join(VALID_STATUSES)}")
    if body.execution_mode is not None and body.execution_mode not in VALID_EXECUTION_MODES:
        raise HTTPException(400, f"Invalid execution_mode '{body.execution_mode}'. Must be one of: {', '.join(VALID_EXECUTION_MODES)}")
    if body.priority is not None and not (1 <= body.priority <= 10):
        raise HTTPException(400, "priority must be between 1 and 10")
    if body.route_type is not None and body.route_type and body.route_type not in VALID_ROUTE_TYPES:
        raise HTTPException(400, f"Invalid route_type '{body.route_type}'. Must be one of: {', '.join(sorted(VALID_ROUTE_TYPES))} or empty string to clear")
    if body.title is not None and not body.title.strip():
        raise HTTPException(400, "title must not be empty")
    all_none = all(v is None for v in [body.status, body.execution_mode, body.priority, body.route_type, body.title, body.brief_text, body.acceptance_criteria])
    if all_none:
        raise HTTPException(400, "Nothing to update.")
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    fields = {}
    if body.status is not None:
        fields["status"] = body.status
    if body.execution_mode is not None:
        fields["execution_mode"] = body.execution_mode
    if body.priority is not None:
        fields["priority"] = body.priority
    if body.title is not None:
        fields["title"] = body.title.strip()
    if body.route_type is not None or body.brief_text is not None:
        current_brief = t.get("brief") or {}
        if isinstance(current_brief, str):
            current_brief = {"text": current_brief}
        if body.route_type is not None:
            if body.route_type:
                current_brief = {**current_brief, "route_type": body.route_type}
            else:
                current_brief = {k: v for k, v in current_brief.items() if k != "route_type"}
        if body.brief_text is not None:
            current_brief = {**current_brief, "text": body.brief_text}
        fields["brief"] = current_brief if current_brief else None
    if body.acceptance_criteria is not None:
        fields["acceptance_criteria"] = body.acceptance_criteria
    models.update_task(conn, task_id, **fields)
    t = models.get_task(conn, task_id)
    conn.close()
    return t


@app.get("/api/tasks/{task_id}/pipeline")
def get_task_pipeline(task_id: str):
    """Get agent_logs for a task (pipeline steps)."""
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    rows = conn.execute(
        """SELECT id, agent_role, action, output_summary, success,
                  duration_seconds, tokens_used, model, cost_usd, created_at
           FROM agent_logs WHERE task_id = ? ORDER BY created_at""",
        (task_id,),
    ).fetchall()
    steps = [dict(r) for r in rows]
    conn.close()
    return steps


@app.get("/api/tasks/{task_id}/full")
def get_task_full(task_id: str):
    """Task + pipeline steps + related decisions."""
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    rows = conn.execute(
        """SELECT id, agent_role, action, output_summary, success,
                  duration_seconds, tokens_used, model, cost_usd, created_at
           FROM agent_logs WHERE task_id = ? ORDER BY created_at""",
        (task_id,),
    ).fetchall()
    steps = [dict(r) for r in rows]
    decisions = models.get_decisions(conn, t["project_id"])
    # Filter to decisions linked to this task
    task_decisions = [d for d in decisions if d.get("task_id") == task_id]
    p = models.get_project(conn, t["project_id"])
    project_deploy_command = p.get("deploy_command") if p else None
    conn.close()
    return {**t, "pipeline_steps": steps, "related_decisions": task_decisions, "project_deploy_command": project_deploy_command}


class TaskApprove(BaseModel):
    decision_title: str | None = None
    decision_description: str | None = None
    decision_type: str = "decision"
    create_followups: bool = False


@app.post("/api/tasks/{task_id}/approve")
def approve_task(task_id: str, body: TaskApprove | None = None):
    """Approve a task: set status=done, optionally add decision and create follow-ups."""
    from core.followup import generate_followups

    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    models.update_task(conn, task_id, status="done")
    try:
        from core.hooks import run_hooks as _run_hooks
        task_modules = models.get_modules(conn, t["project_id"])
        _run_hooks(conn, t["project_id"], task_id,
                   event="task_done", task_modules=task_modules)
    except Exception:
        pass

    # Advance phase state machine if this task belongs to an active phase
    phase_result = None
    phase_row = conn.execute(
        "SELECT * FROM project_phases WHERE task_id = ?", (task_id,)
    ).fetchone()
    if phase_row:
        phase = dict(phase_row)
        if phase.get("status") == "active":
            from core.phases import approve_phase as _approve_phase
            try:
                phase_result = _approve_phase(conn, phase["id"])
            except ValueError:
                pass

    decision = None
    if body and body.decision_title:
        decision = models.add_decision(
            conn, t["project_id"], body.decision_type,
            body.decision_title, body.decision_description or body.decision_title,
            task_id=task_id,
        )
    followup_tasks = []
    pending_actions = []
    if body and body.create_followups:
        result = generate_followups(conn, task_id)
        followup_tasks = result["created"]
        pending_actions = result["pending_actions"]
    conn.close()
    return {
        "status": "done",
        "decision": decision,
        "followup_tasks": followup_tasks,
        "needs_decision": len(pending_actions) > 0,
        "pending_actions": pending_actions,
        "phase": phase_result,
    }


class ResolveAction(BaseModel):
    action: dict
    choice: str  # "rerun" | "manual_task" | "skip"


@app.post("/api/tasks/{task_id}/resolve")
def resolve_action(task_id: str, body: ResolveAction):
    """Resolve a pending permission action from follow-up generation."""
    from core.followup import resolve_pending_action

    if body.choice not in ("rerun", "manual_task", "skip"):
        raise HTTPException(400, f"Invalid choice: {body.choice}")
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    result = resolve_pending_action(conn, task_id, body.action, body.choice)
    conn.close()
    return {"choice": body.choice, "result": result}


class TaskReject(BaseModel):
    reason: str


@app.post("/api/tasks/{task_id}/reject")
def reject_task(task_id: str, body: TaskReject):
    """Reject a task: set status=pending with reason in review field."""
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    models.update_task(conn, task_id, status="pending", review={"rejected": body.reason})
    conn.close()
    return {"status": "pending", "reason": body.reason}


_MAX_REVISE_COUNT = 5


class TaskRevise(BaseModel):
    comment: str
    steps: list[dict] | None = None  # override pipeline steps (optional)
    target_role: str | None = None   # if set, re-run only [target_role, reviewer] instead of full pipeline


@app.post("/api/tasks/{task_id}/revise")
def revise_task(task_id: str, body: TaskRevise):
    """Revise a task: update comment, increment revise_count, and re-run pipeline."""
    if not body.comment.strip():
        raise HTTPException(400, "comment must not be empty")

    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")

    revise_count = (t.get("revise_count") or 0) + 1
    if revise_count > _MAX_REVISE_COUNT:
        conn.close()
        raise HTTPException(400, f"Max revisions ({_MAX_REVISE_COUNT}) reached for this task")

    models.update_task(
        conn, task_id,
        status="in_progress",
        revise_comment=body.comment,
        revise_count=revise_count,
        revise_target_role=body.target_role,
    )

    # Resolve steps: explicit > target_role shortcut > last pipeline steps
    steps = body.steps
    if not steps:
        if body.target_role:
            steps = [{"role": body.target_role}, {"role": "reviewer"}]
        else:
            row = conn.execute(
                "SELECT steps FROM pipelines WHERE task_id = ? ORDER BY id DESC LIMIT 1",
                (task_id,),
            ).fetchone()
            if row:
                import json as _json
                raw = row["steps"]
                steps = _json.loads(raw) if isinstance(raw, str) else raw

    conn.close()

    # Launch pipeline in background subprocess
    _launch_pipeline_subprocess(task_id)

    return {
        "status": "in_progress",
        "comment": body.comment,
        "revise_count": revise_count,
        "pipeline_steps": steps,
    }


@app.get("/api/tasks/{task_id}/running")
def is_task_running(task_id: str):
    """Check if task has an active (running) pipeline."""
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    row = conn.execute(
        "SELECT id, status FROM pipelines WHERE task_id = ? ORDER BY created_at DESC LIMIT 1",
        (task_id,),
    ).fetchone()
    conn.close()
    if row and row["status"] == "running":
        return {"running": True, "pipeline_id": row["id"]}
    return {"running": False}


@app.post("/api/tasks/{task_id}/run")
def run_task(task_id: str):
    """Launch pipeline for a task in background. Returns 202."""
    from agents.runner import check_claude_auth, ClaudeAuthError
    try:
        check_claude_auth()
    except ClaudeAuthError:
        raise HTTPException(503, detail={
            "error": "claude_auth_required",
            "message": "Claude CLI requires login",
            "instructions": "Run: claude login",
        })

    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    if t.get("status") == "in_progress":
        conn.close()
        return JSONResponse({"error": "task_already_running"}, status_code=409)
    # Set task to in_progress immediately so UI updates
    models.update_task(conn, task_id, status="in_progress")
    conn.close()
    # Launch kin run in background subprocess
    kin_root = Path(__file__).parent.parent
    cmd = [sys.executable, "-m", "cli.main", "--db", str(DB_PATH),
           "run", task_id]
    cmd.append("--allow-write")  # always required: subprocess runs non-interactively (stdin=DEVNULL)

    import os
    env = os.environ.copy()
    env["KIN_NONINTERACTIVE"] = "1"

    try:
        proc = subprocess.Popen(
            cmd,
            cwd=str(kin_root),
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            stdin=subprocess.DEVNULL,
            env=env,
        )
        import logging
        logging.getLogger("kin").info(f"Pipeline started for {task_id}, pid={proc.pid}")
    except Exception as e:
        raise HTTPException(500, f"Failed to start pipeline: {e}")
    return JSONResponse({"status": "started", "task_id": task_id}, status_code=202)


# ---------------------------------------------------------------------------
# Decisions
# ---------------------------------------------------------------------------

@app.get("/api/decisions")
def list_decisions(
    project: str = Query(...),
    category: str | None = None,
    tag: list[str] | None = Query(None),
    type: list[str] | None = Query(None),
):
    conn = get_conn()
    decisions = models.get_decisions(
        conn, project, category=category, tags=tag, types=type,
    )
    conn.close()
    return decisions


class DecisionCreate(BaseModel):
    project_id: str
    type: str
    title: str
    description: str
    category: str | None = None
    tags: list[str] | None = None
    task_id: str | None = None


@app.post("/api/decisions")
def create_decision(body: DecisionCreate):
    conn = get_conn()
    p = models.get_project(conn, body.project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{body.project_id}' not found")
    d = models.add_decision(
        conn, body.project_id, body.type, body.title, body.description,
        category=body.category, tags=body.tags, task_id=body.task_id,
    )
    conn.close()
    return d


@app.delete("/api/projects/{project_id}/decisions/{decision_id}")
def delete_decision(project_id: str, decision_id: int):
    conn = get_conn()
    decision = models.get_decision(conn, decision_id)
    if not decision or decision["project_id"] != project_id:
        conn.close()
        raise HTTPException(404, f"Decision #{decision_id} not found")
    models.delete_decision(conn, decision_id)
    conn.close()
    return {"deleted": decision_id}


# ---------------------------------------------------------------------------
# Cost
# ---------------------------------------------------------------------------

@app.get("/api/cost")
def cost_summary(days: int = 7):
    conn = get_conn()
    costs = models.get_cost_summary(conn, days=days)
    conn.close()
    return costs


# ---------------------------------------------------------------------------
# Support
# ---------------------------------------------------------------------------

@app.get("/api/support/tickets")
def list_tickets(project: str | None = None, status: str | None = None):
    conn = get_conn()
    tickets = models.list_tickets(conn, project_id=project, status=status)
    conn.close()
    return tickets


# ---------------------------------------------------------------------------
# Audit
# ---------------------------------------------------------------------------

@app.post("/api/projects/{project_id}/audit")
def audit_project(project_id: str):
    """Run backlog audit — check which pending tasks are already done."""
    from agents.runner import run_audit

    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    result = run_audit(conn, project_id, noninteractive=True, auto_apply=False)
    conn.close()
    return result


class AuditApply(BaseModel):
    task_ids: list[str]


@app.post("/api/projects/{project_id}/audit/apply")
def audit_apply(project_id: str, body: AuditApply):
    """Mark tasks as done after audit confirmation."""
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    updated = []
    for tid in body.task_ids:
        t = models.get_task(conn, tid)
        if t and t["project_id"] == project_id:
            models.update_task(conn, tid, status="done")
            updated.append(tid)
    conn.close()
    return {"updated": updated, "count": len(updated)}


# ---------------------------------------------------------------------------
# Bootstrap
# ---------------------------------------------------------------------------

class BootstrapRequest(BaseModel):
    path: str
    id: str
    name: str
    vault_path: str | None = None


@app.post("/api/bootstrap")
def bootstrap(body: BootstrapRequest):
    project_path = Path(body.path).expanduser().resolve()
    if not project_path.is_dir():
        raise HTTPException(400, f"Path '{body.path}' is not a directory")

    conn = get_conn()
    if models.get_project(conn, body.id):
        conn.close()
        raise HTTPException(409, f"Project '{body.id}' already exists")

    tech_stack = detect_tech_stack(project_path)
    modules = detect_modules(project_path)
    decisions = extract_decisions_from_claude_md(project_path, body.id, body.name)

    obsidian = None
    vault_root = find_vault_root(Path(body.vault_path) if body.vault_path else None)
    if vault_root:
        dir_name = project_path.name
        obs = scan_obsidian(vault_root, body.id, body.name, dir_name)
        if obs["tasks"] or obs["decisions"]:
            obsidian = obs

    try:
        save_to_db(conn, body.id, body.name, str(project_path),
                   tech_stack, modules, decisions, obsidian)
    except Exception as e:
        if models.get_project(conn, body.id):
            models.delete_project(conn, body.id)
        conn.close()
        raise HTTPException(500, f"Bootstrap failed: {e}")
    p = models.get_project(conn, body.id)
    conn.close()
    return {
        "project": p,
        "modules_count": len(modules),
        "decisions_count": len(decisions) + len((obsidian or {}).get("decisions", [])),
        "tasks_count": len((obsidian or {}).get("tasks", [])),
    }


# ---------------------------------------------------------------------------
# Environments (KIN-087)
# ---------------------------------------------------------------------------

VALID_AUTH_TYPES = {"password", "key", "ssh_key"}


class EnvironmentCreate(BaseModel):
    name: str
    host: str
    port: int = 22
    username: str
    auth_type: str = "password"
    auth_value: str | None = None
    is_installed: bool = False

    @model_validator(mode="after")
    def validate_env_fields(self) -> "EnvironmentCreate":
        if not self.name.strip():
            raise ValueError("name must not be empty")
        if not self.host.strip():
            raise ValueError("host must not be empty")
        if not self.username.strip():
            raise ValueError("username must not be empty")
        if self.auth_type not in VALID_AUTH_TYPES:
            raise ValueError(f"auth_type must be one of: {', '.join(VALID_AUTH_TYPES)}")
        if not (1 <= self.port <= 65535):
            raise ValueError("port must be between 1 and 65535")
        return self


class EnvironmentPatch(BaseModel):
    name: str | None = None
    host: str | None = None
    port: int | None = None
    username: str | None = None
    auth_type: str | None = None
    auth_value: str | None = None
    is_installed: bool | None = None


def _trigger_sysadmin_scan(conn, project_id: str, env: dict) -> str:
    """Create a sysadmin env-scan task and launch it in background.

    env must be the raw record from get_environment() (contains obfuscated auth_value).
    Guard: skips if an active sysadmin task for this environment already exists.
    Returns task_id of the created (or existing) task.
    """
    env_id = env["id"]
    existing = conn.execute(
        """SELECT id FROM tasks
           WHERE project_id = ? AND assigned_role = 'sysadmin'
             AND status NOT IN ('done', 'cancelled')
             AND brief LIKE ?""",
        (project_id, f'%"env_id": {env_id}%'),
    ).fetchone()
    if existing:
        return existing["id"]

    task_id = models.next_task_id(conn, project_id, category="INFRA")
    brief = {
        "type": "env_scan",
        "env_id": env_id,
        "host": env["host"],
        "port": env["port"],
        "username": env["username"],
        "auth_type": env["auth_type"],
        # auth_value is decrypted plaintext (get_environment decrypts via _decrypt_auth).
        # Stored in tasks.brief — treat as sensitive.
        "auth_value_b64": env.get("auth_value"),
        "text": (
            f"Провести полный аудит среды '{env['name']}' на сервере {env['host']}.\n\n"
            f"Подключение: {env['username']}@{env['host']}:{env['port']} (auth_type={env['auth_type']}).\n\n"
            "Задачи:\n"
            "1. Проверить git config (user, remote, текущую ветку)\n"
            "2. Установленный стек (python/node/java версии, package managers)\n"
            "3. Переменные окружения (.env файлы, systemd EnvironmentFile)\n"
            "4. Nginx/caddy конфиги (виртуальные хосты, SSL)\n"
            "5. Systemd/supervisor сервисы проекта\n"
            "6. SSH-ключи (authorized_keys, known_hosts)\n"
            "7. Если чего-то не хватает для подключения или аудита — эскалация к человеку."
        ),
    }
    models.create_task(
        conn, task_id, project_id,
        title=f"[{env['name']}] Env scan: {env['host']}",
        assigned_role="sysadmin",
        category="INFRA",
        brief=brief,
    )
    models.update_task(conn, task_id, status="in_progress")

    kin_root = Path(__file__).parent.parent
    cmd = [sys.executable, "-m", "cli.main", "--db", str(DB_PATH), "run", task_id]
    cmd.append("--allow-write")
    import os as _os
    env_vars = _os.environ.copy()
    env_vars["KIN_NONINTERACTIVE"] = "1"
    try:
        subprocess.Popen(
            cmd,
            cwd=str(kin_root),
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL,
            stdin=subprocess.DEVNULL,
            env=env_vars,
        )
    except Exception as e:
        _logger.warning("Failed to start sysadmin scan for %s: %s", task_id, e)

    return task_id


@app.get("/api/projects/{project_id}/environments")
def list_environments(project_id: str):
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    envs = models.list_environments(conn, project_id)
    conn.close()
    return envs


@app.post("/api/projects/{project_id}/environments", status_code=201)
def create_environment(project_id: str, body: EnvironmentCreate):
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    try:
        env = models.create_environment(
            conn, project_id,
            name=body.name,
            host=body.host,
            port=body.port,
            username=body.username,
            auth_type=body.auth_type,
            auth_value=body.auth_value,
            is_installed=body.is_installed,
        )
    except Exception as e:
        conn.close()
        if "UNIQUE constraint" in str(e):
            raise HTTPException(409, f"Environment '{body.name}' already exists for this project")
        if "KIN_SECRET_KEY" in str(e):
            raise HTTPException(503, "Server misconfiguration: KIN_SECRET_KEY is not set. Contact admin.")
        if isinstance(e, ModuleNotFoundError) or "cryptography" in str(e) or "No module named" in str(e):
            raise HTTPException(503, "Server misconfiguration: cryptography package not installed. Run: python3.11 -m pip install cryptography")
        raise HTTPException(500, str(e))
    scan_task_id = None
    if body.is_installed:
        raw_env = models.get_environment(conn, env["id"])
        scan_task_id = _trigger_sysadmin_scan(conn, project_id, raw_env)
    conn.close()
    result = {**env}
    if scan_task_id:
        result["scan_task_id"] = scan_task_id
    return JSONResponse(result, status_code=201)


@app.patch("/api/projects/{project_id}/environments/{env_id}")
def patch_environment(project_id: str, env_id: int, body: EnvironmentPatch):
    all_none = all(v is None for v in [
        body.name, body.host, body.port, body.username,
        body.auth_type, body.auth_value, body.is_installed,
    ])
    if all_none:
        raise HTTPException(400, "Nothing to update.")
    if body.auth_type is not None and body.auth_type not in VALID_AUTH_TYPES:
        raise HTTPException(400, f"auth_type must be one of: {', '.join(VALID_AUTH_TYPES)}")
    if body.port is not None and not (1 <= body.port <= 65535):
        raise HTTPException(400, "port must be between 1 and 65535")
    if body.name is not None and not body.name.strip():
        raise HTTPException(400, "name must not be empty")
    if body.username is not None and not body.username.strip():
        raise HTTPException(400, "username must not be empty")
    if body.host is not None and not body.host.strip():
        raise HTTPException(400, "host must not be empty")

    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    existing = models.get_environment(conn, env_id)
    if not existing or existing.get("project_id") != project_id:
        conn.close()
        raise HTTPException(404, f"Environment #{env_id} not found")

    was_installed = bool(existing.get("is_installed"))

    fields = {}
    if body.name is not None:
        fields["name"] = body.name
    if body.host is not None:
        fields["host"] = body.host
    if body.port is not None:
        fields["port"] = body.port
    if body.username is not None:
        fields["username"] = body.username
    if body.auth_type is not None:
        fields["auth_type"] = body.auth_type
    if body.auth_value:  # only update if non-empty (empty = don't change stored cred)
        fields["auth_value"] = body.auth_value
    if body.is_installed is not None:
        fields["is_installed"] = int(body.is_installed)

    try:
        updated = models.update_environment(conn, env_id, **fields)
    except Exception as e:
        conn.close()
        if "UNIQUE constraint" in str(e):
            raise HTTPException(409, f"Environment name already exists for this project")
        if "KIN_SECRET_KEY" in str(e):
            raise HTTPException(503, "Server misconfiguration: KIN_SECRET_KEY is not set. Contact admin.")
        if isinstance(e, ModuleNotFoundError) or "cryptography" in str(e) or "No module named" in str(e):
            raise HTTPException(503, "Server misconfiguration: cryptography package not installed. Run: python3.11 -m pip install cryptography")
        raise HTTPException(500, str(e))

    scan_task_id = None
    if body.is_installed is True and not was_installed:
        raw_env = models.get_environment(conn, env_id)
        scan_task_id = _trigger_sysadmin_scan(conn, project_id, raw_env)

    conn.close()
    result = {**updated}
    if scan_task_id:
        result["scan_task_id"] = scan_task_id
    return result


@app.delete("/api/projects/{project_id}/environments/{env_id}", status_code=204)
def delete_environment(project_id: str, env_id: int):
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    # Check existence directly — no decryption needed for delete
    row = conn.execute(
        "SELECT project_id FROM project_environments WHERE id = ?", (env_id,)
    ).fetchone()
    if not row or dict(row)["project_id"] != project_id:
        conn.close()
        raise HTTPException(404, f"Environment #{env_id} not found")
    models.delete_environment(conn, env_id)
    conn.close()
    return Response(status_code=204)


@app.post("/api/projects/{project_id}/environments/{env_id}/scan", status_code=202)
def scan_environment(project_id: str, env_id: int):
    """Manually re-trigger sysadmin env scan for an environment."""
    import os as _os
    if not _os.environ.get("KIN_SECRET_KEY"):
        raise HTTPException(503, "Server misconfiguration: KIN_SECRET_KEY is not set. Contact admin.")
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    raw_env = models.get_environment(conn, env_id)
    if not raw_env or raw_env.get("project_id") != project_id:
        conn.close()
        raise HTTPException(404, f"Environment #{env_id} not found")
    task_id = _trigger_sysadmin_scan(conn, project_id, raw_env)
    conn.close()
    return JSONResponse({"status": "started", "task_id": task_id}, status_code=202)


# ---------------------------------------------------------------------------
# Notifications (escalations from blocked agents)
# ---------------------------------------------------------------------------

@app.get("/api/notifications")
def get_notifications(project_id: str | None = None):
    """Return tasks with status='blocked' as escalation notifications.

    Each item includes task details, the agent role that blocked it,
    the reason, the pipeline step, and whether a Telegram alert was sent.
    Intended for GUI polling (5s interval).
    """
    conn = get_conn()
    query = "SELECT * FROM tasks WHERE status = 'blocked'"
    params: list = []
    if project_id:
        query += " AND project_id = ?"
        params.append(project_id)
    query += " ORDER BY blocked_at DESC, updated_at DESC"
    rows = conn.execute(query, params).fetchall()
    conn.close()

    notifications = []
    for row in rows:
        t = dict(row)
        notifications.append({
            "task_id": t["id"],
            "project_id": t["project_id"],
            "title": t.get("title"),
            "agent_role": t.get("blocked_agent_role"),
            "reason": t.get("blocked_reason"),
            "pipeline_step": t.get("blocked_pipeline_step"),
            "blocked_at": t.get("blocked_at") or t.get("updated_at"),
            "telegram_sent": bool(t.get("telegram_sent")),
        })
    return notifications


# ---------------------------------------------------------------------------
# Attachments (KIN-090)
# ---------------------------------------------------------------------------

_MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024  # 10 MB


def _attachment_dir(project_path: Path, task_id: str) -> Path:
    """Return (and create) {project_path}/.kin/attachments/{task_id}/."""
    d = project_path / ".kin" / "attachments" / task_id
    d.mkdir(parents=True, exist_ok=True)
    return d


@app.post("/api/tasks/{task_id}/attachments", status_code=201)
async def upload_attachment(task_id: str, file: UploadFile = File(...)):
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    p = models.get_project(conn, t["project_id"])
    if not p or not p.get("path"):
        conn.close()
        raise HTTPException(400, "Attachments not supported for operations projects")

    # Sanitize filename: strip directory components
    safe_name = Path(file.filename or "upload").name
    if not safe_name:
        conn.close()
        raise HTTPException(400, "Invalid filename")

    att_dir = _attachment_dir(Path(p["path"]), task_id)
    dest = att_dir / safe_name

    # Path traversal guard
    if not dest.is_relative_to(att_dir):
        conn.close()
        raise HTTPException(400, "Invalid filename")

    # Read with size limit
    content = await file.read(_MAX_ATTACHMENT_SIZE + 1)
    if len(content) > _MAX_ATTACHMENT_SIZE:
        conn.close()
        raise HTTPException(413, f"File too large. Maximum size is {_MAX_ATTACHMENT_SIZE // (1024*1024)} MB")

    dest.write_bytes(content)

    mime_type = mimetypes.guess_type(safe_name)[0] or "application/octet-stream"
    attachment = models.create_attachment(
        conn, task_id,
        filename=safe_name,
        path=str(dest),
        mime_type=mime_type,
        size=len(content),
    )
    conn.close()
    return JSONResponse(attachment, status_code=201)


@app.get("/api/tasks/{task_id}/attachments")
def list_task_attachments(task_id: str):
    conn = get_conn()
    t = models.get_task(conn, task_id)
    if not t:
        conn.close()
        raise HTTPException(404, f"Task '{task_id}' not found")
    attachments = models.list_attachments(conn, task_id)
    conn.close()
    return attachments


@app.delete("/api/tasks/{task_id}/attachments/{attachment_id}", status_code=204)
def delete_task_attachment(task_id: str, attachment_id: int):
    conn = get_conn()
    att = models.get_attachment(conn, attachment_id)
    if not att or att["task_id"] != task_id:
        conn.close()
        raise HTTPException(404, f"Attachment #{attachment_id} not found")
    # Delete file from disk
    try:
        Path(att["path"]).unlink(missing_ok=True)
    except Exception:
        pass
    models.delete_attachment(conn, attachment_id)
    conn.close()
    return Response(status_code=204)


@app.get("/api/attachments/{attachment_id}/file")
def get_attachment_file(attachment_id: int):
    conn = get_conn()
    att = models.get_attachment(conn, attachment_id)
    conn.close()
    if not att:
        raise HTTPException(404, f"Attachment #{attachment_id} not found")
    file_path = Path(att["path"])
    if not file_path.exists():
        raise HTTPException(404, "Attachment file not found on disk")
    return FileResponse(
        str(file_path),
        media_type=att["mime_type"],
        filename=att["filename"],
    )


# ---------------------------------------------------------------------------
# Chat (KIN-OBS-012)
# ---------------------------------------------------------------------------

class ChatMessageIn(BaseModel):
    content: str


@app.get("/api/projects/{project_id}/chat")
def get_chat_history(
    project_id: str,
    limit: int = Query(50, ge=1, le=200),
    before_id: int | None = None,
):
    """Return chat history for a project. Enriches task_created messages with task_stub."""
    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")
    messages = models.get_chat_messages(conn, project_id, limit=limit, before_id=before_id)
    for msg in messages:
        if msg.get("message_type") == "task_created" and msg.get("task_id"):
            task = models.get_task(conn, msg["task_id"])
            if task:
                msg["task_stub"] = {
                    "id": task["id"],
                    "title": task["title"],
                    "status": task["status"],
                }
    conn.close()
    return messages


@app.post("/api/projects/{project_id}/chat")
def send_chat_message(project_id: str, body: ChatMessageIn):
    """Process a user message: classify intent, create task or answer, return both messages."""
    from core.chat_intent import classify_intent

    if not body.content.strip():
        raise HTTPException(400, "content must not be empty")

    conn = get_conn()
    p = models.get_project(conn, project_id)
    if not p:
        conn.close()
        raise HTTPException(404, f"Project '{project_id}' not found")

    # 1. Save user message
    user_msg = models.add_chat_message(conn, project_id, "user", body.content)

    # 2. Classify intent
    intent = classify_intent(body.content)

    task = None

    if intent == "task_request":
        # 3a. Create task (category OBS) and run pipeline in background
        task_id = models.next_task_id(conn, project_id, category="OBS")
        title = body.content[:120].strip()
        t = models.create_task(
            conn, task_id, project_id, title,
            brief={"text": body.content, "source": "chat"},
            category="OBS",
        )
        task = t

        import os as _os
        env_vars = _os.environ.copy()
        env_vars["KIN_NONINTERACTIVE"] = "1"
        kin_root = Path(__file__).parent.parent
        try:
            subprocess.Popen(
                [sys.executable, "-m", "cli.main", "--db", str(DB_PATH),
                 "run", task_id, "--allow-write"],
                cwd=str(kin_root),
                stdout=subprocess.DEVNULL,
                stderr=subprocess.DEVNULL,
                stdin=subprocess.DEVNULL,
                env=env_vars,
            )
        except Exception as e:
            _logger.warning("Failed to start pipeline for chat task %s: %s", task_id, e)

        assistant_content = f"Создал задачу {task_id}: {title}"
        assistant_msg = models.add_chat_message(
            conn, project_id, "assistant", assistant_content,
            message_type="task_created", task_id=task_id,
        )
        assistant_msg["task_stub"] = {
            "id": t["id"],
            "title": t["title"],
            "status": t["status"],
        }

    elif intent == "status_query":
        # 3b. Return current task status summary
        in_progress = models.list_tasks(conn, project_id=project_id, status="in_progress")
        pending = models.list_tasks(conn, project_id=project_id, status="pending")
        review = models.list_tasks(conn, project_id=project_id, status="review")

        parts = []
        if in_progress:
            parts.append("В работе ({}):\n{}".format(
                len(in_progress),
                "\n".join(f"  • {t['id']} — {t['title'][:60]}" for t in in_progress[:5]),
            ))
        if review:
            parts.append("На ревью ({}):\n{}".format(
                len(review),
                "\n".join(f"  • {t['id']} — {t['title'][:60]}" for t in review[:5]),
            ))
        if pending:
            parts.append("Ожидает ({}):\n{}".format(
                len(pending),
                "\n".join(f"  • {t['id']} — {t['title'][:60]}" for t in pending[:5]),
            ))

        content = "\n\n".join(parts) if parts else "Нет активных задач."
        assistant_msg = models.add_chat_message(conn, project_id, "assistant", content)

    else:  # question
        assistant_msg = models.add_chat_message(
            conn, project_id, "assistant",
            "Я пока не умею отвечать на вопросы напрямую. "
            "Если хотите — опишите задачу, я создам её и запущу агентов.",
        )

    conn.close()
    return {
        "user_message": user_msg,
        "assistant_message": assistant_msg,
        "task": task,
    }


# ---------------------------------------------------------------------------
# SPA static files (AFTER all /api/ routes)
# ---------------------------------------------------------------------------

DIST = Path(__file__).parent / "frontend" / "dist"

app.mount("/assets", StaticFiles(directory=str(DIST / "assets")), name="assets")


@app.get("/{path:path}")
async def serve_spa(path: str):
    file = DIST / path
    if file.exists() and file.is_file():
        return FileResponse(file)
    return FileResponse(DIST / "index.html")