Upload folder using huggingface_hub

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,9 @@
+[
+  "tests/test_api_flow.py::test_full_9_question_flow_and_results",
+  "tests/test_api_flow.py::test_health",
+  "tests/test_api_flow.py::test_mock_mode_autogenerated_answers_flow",
+  "tests/test_api_flow.py::test_summary_audio_after_completion",
+  "tests/test_api_flow.py::test_transcribe_preview",
+  "tests/test_preflight_unittest.py::PreflightFlowTest::test_9_question_journey",
+  "tests/test_preflight_unittest.py::PreflightFlowTest::test_health"
+]

.pytest_cache/v/cache/stepwise

@@ -0,0 +1 @@
+[]

app/agent/state.py

@@ -4,6 +4,7 @@ from app.models.checklist import ChecklistItem
 from app.models.portrait import PortraitCard
 from app.models.question import Question
 from app.models.session import Answer
+from app.models.tooling import ToolInsight
 
 
 class AgentState(TypedDict):
@@ -18,6 +19,7 @@ class AgentState(TypedDict):
     round_summaries: List[str]
     round_summary: str
     checklist_items: List[ChecklistItem]
+    tool_insights: List[ToolInsight]
     portrait: Optional[PortraitCard]
     markdown_content: str
     is_complete: bool

app/main.py

@@ -12,6 +12,7 @@ from app.services.mcp import MCPToolProvider
 from app.services.portrait import PortraitService
 from app.services.transcription import TranscriptionService
 from app.services.tts import TTSService
+from app.storage.job_store import JobStore
 from app.storage.session_store import SessionStore
 
 
@@ -36,6 +37,7 @@ async def lifespan(app: FastAPI):
     app.state.mcp_provider = mcp_provider
     app.state.graph_service = ChecklistGraphService(llm_service, portrait_service=portrait_service)
     app.state.session_store = SessionStore()
+    app.state.job_store = JobStore()
 
     yield
 

app/models/job.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from app.models.question import Question
+
+JobStatus = Literal["queued", "running", "completed", "failed"]
+StepStatus = Literal["pending", "running", "completed", "failed"]
+
+
+class JobStep(BaseModel):
+    key: str
+    label: str
+    status: StepStatus = "pending"
+    eta_seconds: int = 0
+
+
+class JobResult(BaseModel):
+    round: int
+    questions: List[Question] = Field(default_factory=list)
+    round_summary: str
+    is_complete: bool
+    checklist_preview: Optional[str] = None
+
+
+class SessionSubmitAcceptedResponse(BaseModel):
+    job_id: str
+    status: JobStatus
+    current_step: Optional[str] = None
+    eta_seconds_left: int
+    progress_pct: int
+
+
+class JobStatusResponse(BaseModel):
+    job_id: str
+    session_id: str
+    status: JobStatus
+    current_step: Optional[str] = None
+    steps: List[JobStep] = Field(default_factory=list)
+    eta_seconds_left: int
+    progress_pct: int
+    error: Optional[str] = None
+    result: Optional[JobResult] = None

app/models/session.py

@@ -5,11 +5,13 @@ from pydantic import BaseModel, Field
 from app.models.checklist import ChecklistItem
 from app.models.portrait import PortraitCard
 from app.models.question import Question
+from app.models.tooling import ToolInsight
 
 
 class StartSessionRequest(BaseModel):
     goal: str = Field(default="Заполнить чеклист созвона с клиентом")
     topic: str = Field(default="Бриф по проекту")
+    mock_mode: bool = Field(default=False)
 
 
 class Answer(BaseModel):
@@ -25,10 +27,12 @@ class SessionData(BaseModel):
     topic: str
     current_round: int = 1
     max_rounds: int = 3
+    mock_mode: bool = False
     current_questions: List[Question] = Field(default_factory=list)
     all_answers: List[Answer] = Field(default_factory=list)
     round_summaries: List[str] = Field(default_factory=list)
     checklist_items: List[ChecklistItem] = Field(default_factory=list)
+    tool_insights: List[ToolInsight] = Field(default_factory=list)
     portrait: Optional[PortraitCard] = None
     markdown_content: str = ""
     is_complete: bool = False
@@ -37,6 +41,7 @@ class SessionData(BaseModel):
 class SessionStartResponse(BaseModel):
     session_id: str
     round: int
+    mock_mode: bool = False
     questions: List[Question]
 
 
@@ -48,10 +53,24 @@ class SessionSubmitResponse(BaseModel):
     checklist_preview: Optional[str] = None
 
 
+class MockAnswerPreview(BaseModel):
+    question_id: str
+    question_text: str
+    transcript: str
+
+
+class MockAnswersResponse(BaseModel):
+    session_id: str
+    round: int
+    answers: List[MockAnswerPreview]
+    logs: List[str] = Field(default_factory=list)
+
+
 class SessionResultsResponse(BaseModel):
     session_id: str
     is_complete: bool
     checklist: List[ChecklistItem]
+    tool_insights: List[ToolInsight]
     markdown: str
     round_summaries: List[str]
     portrait: Optional[PortraitCard] = None

app/models/tooling.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from pydantic import BaseModel, Field
+
+
+class ToolInsight(BaseModel):
+    tool_name: str
+    title: str
+    summary: str
+    details: Dict[str, str] = Field(default_factory=dict)

app/routers/session.py

@@ -8,14 +8,18 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import PlainTextResponse, Response
 
 from app.agent.state import AgentState
+from app.models.job import JobResult, JobStatusResponse, SessionSubmitAcceptedResponse
+from app.models.question import Question
 from app.models.session import (
     Answer,
+    MockAnswerPreview,
+    MockAnswersResponse,
     SessionData,
     SessionResultsResponse,
     SessionStartResponse,
-    SessionSubmitResponse,
     StartSessionRequest,
 )
+from app.services.file_generator import build_markdown
 
 router = APIRouter(prefix="/api/session", tags=["session"])
 
@@ -27,6 +31,177 @@ def _decode_base64_audio(encoded: str) -> bytes:
         raise HTTPException(status_code=422, detail="Invalid audio_base64 payload") from exc
 
 
+def _job_steps_for_round(current_round: int, max_rounds: int) -> list[str]:
+    steps = ["transcribe_1", "transcribe_2", "transcribe_3", "analyze_round", "tool_planning", "tool_execution"]
+    if current_round < max_rounds:
+        steps.append("generate_next_questions")
+    else:
+        steps.append("finalize")
+    return steps
+
+
+def _to_questions(texts: list[str]) -> list[Question]:
+    return [Question(id=str(uuid4()), text=text) for text in texts[:3]]
+
+
+async def _process_submit_job(
+    *,
+    job_id: str,
+    session_id: str,
+    question_id_list: list[str],
+    files_payload: list[tuple[bytes, str]],
+    transcripts_payload: list[str] | None,
+    app,
+) -> None:
+    store = app.state.session_store
+    transcription_service = app.state.transcription_service
+    llm_service = app.state.llm_service
+    portrait_service = app.state.portrait_service
+    job_store = app.state.job_store
+
+    try:
+        job_store.mark_running(job_id)
+        session = store.get(session_id)
+        if not session:
+            raise RuntimeError("Session not found")
+        if session.is_complete:
+            raise RuntimeError("Session already completed")
+
+        current_question_map = {q.id: q.text for q in session.current_questions}
+        round_answers: list[Answer] = []
+
+        for idx, qid in enumerate(question_id_list):
+            step_key = f"transcribe_{idx + 1}"
+            job_store.mark_step_running(job_id, step_key)
+            if transcripts_payload is not None:
+                transcript = transcripts_payload[idx].strip()
+            else:
+                audio_bytes, filename = files_payload[idx]
+                transcript = await transcription_service.transcribe(audio_bytes, filename=filename)
+            job_store.mark_step_completed(job_id, step_key)
+            round_answers.append(
+                Answer(
+                    question_id=qid,
+                    question_text=current_question_map.get(qid, f"Question {idx + 1}"),
+                    audio_transcript=transcript,
+                    round_number=session.current_round,
+                )
+            )
+
+        all_answers = [*session.all_answers, *round_answers]
+
+        job_store.mark_step_running(job_id, "analyze_round")
+        summary_candidate = await llm_service.summarize_round(
+            round_number=session.current_round,
+            answers=round_answers,
+        )
+        round_summary = llm_service.ensure_distinct_round_summary(
+            round_number=session.current_round,
+            answers=round_answers,
+            previous_summaries=session.round_summaries,
+            candidate=summary_candidate,
+        )
+        round_summaries = [*session.round_summaries, round_summary]
+        job_store.mark_step_completed(job_id, "analyze_round")
+
+        target = "next_questions" if session.current_round < session.max_rounds else "final_checklist"
+
+        job_store.mark_step_running(job_id, "tool_planning")
+        planned_tools = llm_service.plan_tools_for_round(
+            round_number=session.current_round,
+            topic=session.topic,
+            all_answers=all_answers,
+            latest_round_answers=round_answers,
+            target=target,
+        )
+        job_store.mark_step_completed(job_id, "tool_planning")
+
+        job_store.mark_step_running(job_id, "tool_execution")
+        tool_insights = await llm_service.run_tools_for_round(
+            planned_tools=planned_tools,
+            topic=session.topic,
+            all_answers=all_answers,
+        )
+        tool_context = llm_service.render_tool_context(tool_insights)
+        job_store.mark_step_completed(job_id, "tool_execution")
+
+        if session.current_round < session.max_rounds:
+            job_store.mark_step_running(job_id, "generate_next_questions")
+            next_round = session.current_round + 1
+            next_questions_text = await llm_service.generate_next_questions(
+                goal=session.goal,
+                topic=session.topic,
+                all_answers=all_answers,
+                round_summaries=round_summaries,
+                next_round=next_round,
+                tool_context=tool_context,
+            )
+            next_questions = _to_questions(next_questions_text)
+            job_store.mark_step_completed(job_id, "generate_next_questions")
+
+            session.current_round = next_round
+            session.current_questions = next_questions
+            session.all_answers = all_answers
+            session.round_summaries = round_summaries
+            session.tool_insights = [*session.tool_insights, *tool_insights]
+            session.is_complete = False
+            store.update(session)
+
+            job_store.mark_completed(
+                job_id,
+                JobResult(
+                    round=session.current_round,
+                    questions=next_questions,
+                    round_summary=round_summary,
+                    is_complete=False,
+                    checklist_preview=None,
+                ),
+            )
+            return
+
+        job_store.mark_step_running(job_id, "finalize")
+        checklist = await llm_service.build_final_checklist(
+            goal=session.goal,
+            topic=session.topic,
+            answers=all_answers,
+            round_summaries=round_summaries,
+            tool_context=tool_context,
+        )
+        portrait = portrait_service.analyze(all_answers)
+        all_tool_insights = [*session.tool_insights, *tool_insights]
+        markdown = build_markdown(
+            session_id=session.session_id,
+            topic=session.topic,
+            checklist=checklist,
+            answers=all_answers,
+            tool_insights=all_tool_insights,
+        )
+        job_store.mark_step_completed(job_id, "finalize")
+
+        session.current_questions = []
+        session.all_answers = all_answers
+        session.round_summaries = round_summaries
+        session.checklist_items = checklist
+        session.portrait = portrait
+        session.tool_insights = all_tool_insights
+        session.markdown_content = markdown
+        session.is_complete = True
+        store.update(session)
+
+        job_store.mark_completed(
+            job_id,
+            JobResult(
+                round=session.current_round,
+                questions=[],
+                round_summary=round_summary,
+                is_complete=True,
+                checklist_preview=markdown,
+            ),
+        )
+    except Exception as exc:
+        job_store.mark_failed(job_id, str(exc))
+
+
 @router.post("/start", response_model=SessionStartResponse)
 async def start_session(payload: StartSessionRequest, request: Request):
     session_id = str(uuid4())
@@ -45,6 +220,7 @@ async def start_session(payload: StartSessionRequest, request: Request):
         "round_summaries": [],
         "round_summary": "",
         "checklist_items": [],
+        "tool_insights": [],
         "portrait": None,
         "markdown_content": "",
         "is_complete": False,
@@ -57,6 +233,7 @@ async def start_session(payload: StartSessionRequest, request: Request):
         topic=payload.topic,
         current_round=output["current_round"],
         max_rounds=3,
+        mock_mode=payload.mock_mode,
         current_questions=output["current_questions"],
     )
     session_store.create(session)
@@ -64,6 +241,7 @@ async def start_session(payload: StartSessionRequest, request: Request):
     return SessionStartResponse(
         session_id=session_id,
         round=session.current_round,
+        mock_mode=session.mock_mode,
         questions=session.current_questions,
     )
 
@@ -77,10 +255,60 @@ async def get_session(session_id: str, request: Request):
     return SessionStartResponse(
         session_id=session.session_id,
         round=session.current_round,
+        mock_mode=session.mock_mode,
         questions=session.current_questions,
     )
 
 
+@router.post("/{session_id}/mock-answers", response_model=MockAnswersResponse)
+async def generate_mock_answers(session_id: str, request: Request):
+    store = request.app.state.session_store
+    llm_service = request.app.state.llm_service
+
+    session = store.get(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    if session.is_complete:
+        raise HTTPException(status_code=400, detail="Session already completed")
+    if not session.mock_mode:
+        raise HTTPException(status_code=400, detail="Session is not in mock mode")
+
+    questions = session.current_questions
+    if len(questions) != 3:
+        raise HTTPException(status_code=400, detail="Expected exactly 3 active questions")
+
+    question_texts = [q.text for q in questions]
+    transcripts = await llm_service.generate_mock_answers(
+        goal=session.goal,
+        topic=session.topic,
+        round_number=session.current_round,
+        questions=question_texts,
+    )
+    if len(transcripts) < 3:
+        transcripts = [
+            *transcripts,
+            *["Нужны дополнительные вводные по этому пункту." for _ in range(3 - len(transcripts))],
+        ]
+
+    logs = [
+        "mock_mode=true: аудио не требуется, ответы сгенериро��аны автоматически",
+        f"Раунд {session.current_round}: создано {len(transcripts[:3])} транскриптов",
+    ]
+    return MockAnswersResponse(
+        session_id=session.session_id,
+        round=session.current_round,
+        answers=[
+            MockAnswerPreview(
+                question_id=q.id,
+                question_text=q.text,
+                transcript=transcripts[idx].strip(),
+            )
+            for idx, q in enumerate(questions[:3])
+        ],
+        logs=logs,
+    )
+
+
 @router.post("/transcribe")
 async def transcribe_audio(request: Request):
     transcription_service = request.app.state.transcription_service
@@ -105,14 +333,13 @@ async def transcribe_audio(request: Request):
     return {"transcript": transcript}
 
 
-@router.post("/{session_id}/submit", response_model=SessionSubmitResponse)
+@router.post("/{session_id}/submit", response_model=SessionSubmitAcceptedResponse)
 async def submit_answers(
     session_id: str,
     request: Request,
 ):
     store = request.app.state.session_store
-    graph_service = request.app.state.graph_service
-    transcription_service = request.app.state.transcription_service
+    job_store = request.app.state.job_store
 
     session = store.get(session_id)
     if not session:
@@ -121,6 +348,7 @@ async def submit_answers(
         raise HTTPException(status_code=400, detail="Session already completed")
 
     content_type = request.headers.get("content-type", "")
+    transcripts_payload: list[str] | None = None
     if content_type.startswith("multipart/form-data"):
         form = await request.form()
         raw_question_ids = str(form.get("question_ids", ""))
@@ -133,74 +361,61 @@ async def submit_answers(
         payload = await request.json()
         raw_question_ids = str(payload.get("question_ids", ""))
         encoded_files = payload.get("audio_base64_files", [])
-        files_payload = [(_decode_base64_audio(encoded), f"answer-{idx + 1}.webm") for idx, encoded in enumerate(encoded_files)]
+        transcripts = payload.get("transcripts", [])
+        if transcripts:
+            if not session.mock_mode:
+                raise HTTPException(status_code=400, detail="transcripts mode is allowed only for mock_mode sessions")
+            transcripts_payload = [str(item).strip() for item in transcripts]
+            files_payload = []
+        else:
+            files_payload = [(_decode_base64_audio(encoded), f"answer-{idx + 1}.webm") for idx, encoded in enumerate(encoded_files)]
 
     question_id_list = [item.strip() for item in raw_question_ids.split(",") if item.strip()]
-    if len(files_payload) != 3 or len(question_id_list) != 3:
-        raise HTTPException(status_code=422, detail="Expected 3 audio files and 3 question IDs")
-
-    current_question_map = {q.id: q.text for q in session.current_questions}
-
-    round_answers: list[Answer] = []
-    for idx, (audio_bytes, filename) in enumerate(files_payload):
-        transcript = await transcription_service.transcribe(audio_bytes, filename=filename)
-        qid = question_id_list[idx]
-        round_answers.append(
-            Answer(
-                question_id=qid,
-                question_text=current_question_map.get(qid, f"Question {idx + 1}"),
-                audio_transcript=transcript,
-                round_number=session.current_round,
-            )
-        )
+    if len(question_id_list) != 3:
+        raise HTTPException(status_code=422, detail="Expected 3 question IDs")
+    if transcripts_payload is not None:
+        if len(transcripts_payload) != 3:
+            raise HTTPException(status_code=422, detail="Expected 3 transcripts in mock mode")
+    elif len(files_payload) != 3:
+        raise HTTPException(status_code=422, detail="Expected 3 audio files")
+
+    job_id = str(uuid4())
+    record = job_store.create(
+        job_id=job_id,
+        session_id=session_id,
+        step_keys=_job_steps_for_round(session.current_round, session.max_rounds),
+    )
 
-    all_answers = [*session.all_answers, *round_answers]
-
-    state: AgentState = {
-        "session_id": session.session_id,
-        "goal": session.goal,
-        "topic": session.topic,
-        "current_round": session.current_round,
-        "max_rounds": session.max_rounds,
-        "current_questions": session.current_questions,
-        "all_answers": all_answers,
-        "latest_round_answers": round_answers,
-        "round_summaries": session.round_summaries,
-        "round_summary": "",
-        "checklist_items": session.checklist_items,
-        "portrait": session.portrait,
-        "markdown_content": session.markdown_content,
-        "is_complete": session.is_complete,
-    }
+    asyncio.create_task(
+        _process_submit_job(
+            job_id=job_id,
+            session_id=session_id,
+            question_id_list=question_id_list,
+            files_payload=files_payload,
+            transcripts_payload=transcripts_payload,
+            app=request.app,
+        )
+    )
 
-    try:
-        # Final round may include slower LLM/MCP calls; guard against infinite waits.
-        output = await asyncio.wait_for(graph_service.advance(state), timeout=120.0)
-    except asyncio.TimeoutError as exc:
-        raise HTTPException(
-            status_code=504,
-            detail="Обработка раунда заняла слишком много времени. Повторите отправку.",
-        ) from exc
-
-    session.current_round = output["current_round"]
-    session.current_questions = output.get("current_questions", [])
-    session.all_answers = all_answers
-    session.round_summaries = output.get("round_summaries", session.round_summaries)
-    session.checklist_items = output.get("checklist_items", session.checklist_items)
-    session.portrait = output.get("portrait", session.portrait)
-    session.markdown_content = output.get("markdown_content", session.markdown_content)
-    session.is_complete = output.get("is_complete", False)
-    store.update(session)
-
-    return SessionSubmitResponse(
-        round=session.current_round,
-        questions=session.current_questions,
-        round_summary=output.get("round_summary", ""),
-        is_complete=session.is_complete,
-        checklist_preview=session.markdown_content if session.is_complete else None,
+    snapshot = record.as_response()
+    return SessionSubmitAcceptedResponse(
+        job_id=snapshot.job_id,
+        status=snapshot.status,
+        current_step=snapshot.current_step,
+        eta_seconds_left=snapshot.eta_seconds_left,
+        progress_pct=snapshot.progress_pct,
     )
 
 
+@router.get("/jobs/{job_id}", response_model=JobStatusResponse)
+async def get_submit_job(job_id: str, request: Request):
+    job_store = request.app.state.job_store
+    record = job_store.get(job_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return record.as_response()
+
+
 @router.get("/{session_id}/results", response_model=SessionResultsResponse)
 async def get_results(session_id: str, request: Request):
     store = request.app.state.session_store
@@ -212,6 +427,7 @@ async def get_results(session_id: str, request: Request):
         session_id=session.session_id,
         is_complete=session.is_complete,
         checklist=session.checklist_items,
+        tool_insights=session.tool_insights,
         markdown=session.markdown_content,
         round_summaries=session.round_summaries,
         portrait=session.portrait,

app/services/file_generator.py

@@ -1,10 +1,19 @@
+from __future__ import annotations
+
 from datetime import datetime
 
 from app.models.checklist import ChecklistItem
 from app.models.session import Answer
+from app.models.tooling import ToolInsight
 
 
-def build_markdown(session_id: str, topic: str, checklist: list[ChecklistItem], answers: list[Answer]) -> str:
+def build_markdown(
+    session_id: str,
+    topic: str,
+    checklist: list[ChecklistItem],
+    answers: list[Answer],
+    tool_insights: list[ToolInsight] | None = None,
+) -> str:
     lines: list[str] = []
     lines.append("# Чеклист созвона с клиентом")
     lines.append("")
@@ -30,6 +39,15 @@ def build_markdown(session_id: str, topic: str, checklist: list[ChecklistItem],
         lines.append(f"- Раунд {answer.round_number}: **{answer.question_text}**")
         lines.append(f"  - {answer.audio_transcript}")
 
+    if tool_insights:
+        lines.append("")
+        lines.append("## Инструменты агента")
+        for insight in tool_insights:
+            lines.append(f"- **{insight.title}**: {insight.summary}")
+            if insight.details:
+                details = "; ".join(f"{k}: {v}" for k, v in insight.details.items())
+                lines.append(f"  - {details}")
+
     lines.append("")
     lines.append("---")
     lines.append("*Сгенерировано автоматически AI Checklist Agent*")

app/services/insight_tools.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import asyncio
+import re
+import sqlite3
+from collections import Counter
+from typing import Any, Dict, List, Optional
+
+from app.models.session import Answer
+from app.models.tooling import ToolInsight
+from app.services.mcp import MCPToolProvider
+
+_RU_STOPWORDS = {
+    "и",
+    "в",
+    "во",
+    "на",
+    "по",
+    "с",
+    "со",
+    "к",
+    "у",
+    "для",
+    "из",
+    "а",
+    "но",
+    "что",
+    "как",
+    "это",
+    "мы",
+    "вы",
+    "они",
+    "он",
+    "она",
+    "не",
+    "да",
+    "или",
+    "ли",
+    "бы",
+    "быть",
+    "есть",
+    "будет",
+    "уже",
+    "еще",
+    "очень",
+    "тема",
+    "проект",
+}
+
+_UNCERTAINTY_MARKERS = (
+    "не знаю",
+    "наверно",
+    "наверное",
+    "возможно",
+    "может быть",
+    "пока не",
+    "сложно сказать",
+    "уточнить",
+    "не уверен",
+)
+
+_CALCULATOR_HINTS = (
+    "бюджет",
+    "срок",
+    "дней",
+    "недель",
+    "месяц",
+    "процент",
+    "%",
+    "стоимость",
+    "цена",
+    "доход",
+    "расход",
+)
+
+
+class InsightToolsService:
+    def __init__(self, mcp_provider: Optional[MCPToolProvider] = None) -> None:
+        self._mcp_provider = mcp_provider
+
+    def plan_tools(
+        self,
+        *,
+        round_number: int,
+        topic: str,
+        all_answers: List[Answer],
+        latest_round_answers: List[Answer],
+        target: str,
+    ) -> List[str]:
+        planned = ["session_db"]
+
+        transcript_pool = " ".join(a.audio_transcript.lower() for a in latest_round_answers or all_answers)
+        has_digits = bool(re.search(r"\d", transcript_pool))
+        has_calc_hints = any(hint in transcript_pool for hint in _CALCULATOR_HINTS)
+
+        if target == "next_questions" or round_number <= 2:
+            planned.append("research")
+
+        if has_digits or has_calc_hints:
+            planned.append("calculator")
+
+        # Keep tool set stable for final round even when numbers are absent.
+        if target == "final_checklist" and "calculator" not in planned:
+            planned.append("calculator")
+
+        # Preserve order, remove accidental duplicates.
+        ordered_unique: list[str] = []
+        for item in planned:
+            if item not in ordered_unique:
+                ordered_unique.append(item)
+        return ordered_unique
+
+    async def run_tools(
+        self,
+        *,
+        planned_tools: List[str],
+        topic: str,
+        all_answers: List[Answer],
+    ) -> List[ToolInsight]:
+        out: list[ToolInsight] = []
+        for tool_name in planned_tools:
+            if tool_name == "session_db":
+                out.append(self._session_db_tool(all_answers))
+            elif tool_name == "calculator":
+                out.append(self._calculator_tool(all_answers))
+            elif tool_name == "research":
+                out.append(await self._research_tool(topic))
+        return out
+
+    @staticmethod
+    def render_context(insights: List[ToolInsight]) -> str:
+        if not insights:
+            return ""
+        lines = ["Инструментальные наблюдения:"]
+        for idx, insight in enumerate(insights, start=1):
+            details = "; ".join(f"{k}: {v}" for k, v in insight.details.items() if str(v).strip())
+            if details:
+                lines.append(f"{idx}. {insight.title}: {insight.summary} ({details})")
+            else:
+                lines.append(f"{idx}. {insight.title}: {insight.summary}")
+        return "\n".join(lines)
+
+    def _session_db_tool(self, answers: List[Answer]) -> ToolInsight:
+        conn = sqlite3.connect(":memory:")
+        try:
+            conn.execute(
+                "CREATE TABLE answers (round_number INTEGER, question_text TEXT, transcript TEXT)"
+            )
+            conn.executemany(
+                "INSERT INTO answers(round_number, question_text, transcript) VALUES (?, ?, ?)",
+                [(a.round_number, a.question_text, a.audio_transcript) for a in answers],
+            )
+            row = conn.execute(
+                "SELECT COUNT(*), AVG(LENGTH(transcript)), COUNT(DISTINCT round_number) FROM answers"
+            ).fetchone()
+            total_answers = int(row[0] or 0)
+            avg_len = int(round(float(row[1] or 0.0)))
+            rounds_covered = int(row[2] or 0)
+
+            joined = " ".join(a.audio_transcript.lower() for a in answers)
+            tokens = re.findall(r"[a-zA-Zа-яА-ЯёЁ0-9]{3,}", joined)
+            words = [w for w in tokens if w not in _RU_STOPWORDS and not w.isdigit()]
+            top_words = [word for word, _count in Counter(words).most_common(5)]
+            uncertainty_hits = sum(1 for marker in _UNCERTAINTY_MARKERS if marker in joined)
+
+            summary = (
+                f"В базе {total_answers} ответов по {rounds_covered} раундам; "
+                f"средняя длина ответа {avg_len} символов."
+            )
+            details = {
+                "топ-темы": ", ".join(top_words) if top_words else "нет выраженных тем",
+                "маркеры_неопределенности": str(uncertainty_hits),
+            }
+            return ToolInsight(
+                tool_name="session_db",
+                title="Session DB Lens",
+                summary=summary,
+                details=details,
+            )
+        finally:
+            conn.close()
+
+    def _calculator_tool(self, answers: List[Answer]) -> ToolInsight:
+        text = " ".join(a.audio_transcript for a in answers)
+        raw_numbers = re.findall(r"\d+(?:[.,]\d+)?", text)
+        values = [float(item.replace(",", ".")) for item in raw_numbers]
+        percent_mentions = len(re.findall(r"\d+(?:[.,]\d+)?\s*%", text))
+
+        if not values:
+            return ToolInsight(
+                tool_name="calculator",
+                title="Numeric Estimator",
+                summary="Числовые ориентиры не обнаружены; стоит запросить KPI, бюджет и сроки в цифрах.",
+                details={"чисел": "0", "проценты": str(percent_mentions)},
+            )
+
+        avg_value = sum(values) / len(values)
+        summary = (
+            f"Найдены числовые ориентиры: {len(values)} значений, "
+            f"диапазон {min(values):.0f}-{max(values):.0f}, среднее {avg_value:.1f}."
+        )
+        return ToolInsight(
+            tool_name="calculator",
+            title="Numeric Estimator",
+            summary=summary,
+            details={
+                "чисел": str(len(values)),
+                "минимум": f"{min(values):.0f}",
+                "максимум": f"{max(values):.0f}",
+                "проценты": str(percent_mentions),
+            },
+        )
+
+    async def _research_tool(self, topic: str) -> ToolInsight:
+        fallback = self._fallback_research(topic)
+        if self._mcp_provider is None:
+            return fallback
+
+        try:
+            tools = await asyncio.wait_for(self._mcp_provider.get_tools(), timeout=8.0)
+        except Exception:
+            return fallback
+
+        if not tools:
+            return fallback
+
+        for tool in tools[:2]:
+            try:
+                result = await asyncio.wait_for(tool.ainvoke({"query": topic}), timeout=7.0)
+            except Exception:
+                try:
+                    result = await asyncio.wait_for(tool.ainvoke(topic), timeout=7.0)
+                except Exception:
+                    continue
+            text = re.sub(r"\s+", " ", str(result)).strip()
+            if not text:
+                continue
+            snippet = text[:260]
+            return ToolInsight(
+                tool_name="research",
+                title="Research Probe",
+                summary=f"MCP-результат по теме '{topic}': {snippet}",
+                details={"источник": "mcp", "длина": str(len(text))},
+            )
+
+        return fallback
+
+    @staticmethod
+    def _fallback_research(topic: str) -> ToolInsight:
+        normalized = topic.lower()
+        if "теннис" in normalized:
+            summary = (
+                "Для турниров критичны логистика кортов, сетка матчей, судейство, "
+                "питание и сценарий непогоды."
+            )
+            notes = "расписание, регламент, риски переноса"
+        else:
+            summary = (
+                "Для discovery-интервью обычно важны KPI, владелец процесса, "
+                "ограничения бюджета/сроков и критерии успеха пилота."
+            )
+            notes = "kpi, роли, дедлайны, критерии stop/go"
+
+        return ToolInsight(
+            tool_name="research",
+            title="Research Probe",
+            summary=summary,
+            details={"источник": "fallback", "ключевые_узлы": notes},
+        )

app/services/llm.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import json
 import logging
 import re
@@ -11,6 +10,8 @@ import httpx
 from app.config import Settings
 from app.models.checklist import ChecklistItem
 from app.models.session import Answer
+from app.models.tooling import ToolInsight
+from app.services.insight_tools import InsightToolsService
 from app.services.mcp import MCPToolProvider
 
 logger = logging.getLogger(__name__)
@@ -20,6 +21,7 @@ class LLMService:
     def __init__(self, settings: Settings, mcp_provider: Optional[MCPToolProvider] = None) -> None:
         self.settings = settings
         self._mcp_provider = mcp_provider
+        self._insight_tools = InsightToolsService(mcp_provider=mcp_provider)
         self._provider = settings.llm_provider.lower().strip()
         self._model = None
 
@@ -68,29 +70,39 @@ class LLMService:
 
         return None
 
-    async def _research_context(self, topic: str) -> str:
-        if self._mcp_provider is None:
-            return ""
-
-        try:
-            tools = await asyncio.wait_for(self._mcp_provider.get_tools(), timeout=10.0)
-        except Exception:
-            return ""
-        if not tools:
-            return ""
+    def plan_tools_for_round(
+        self,
+        *,
+        round_number: int,
+        topic: str,
+        all_answers: List[Answer],
+        latest_round_answers: List[Answer],
+        target: str,
+    ) -> List[str]:
+        return self._insight_tools.plan_tools(
+            round_number=round_number,
+            topic=topic,
+            all_answers=all_answers,
+            latest_round_answers=latest_round_answers,
+            target=target,
+        )
 
-        snippets: list[str] = []
-        for tool in tools[:2]:
-            try:
-                result = await asyncio.wait_for(tool.ainvoke({"query": topic}), timeout=6.0)
-            except Exception:
-                try:
-                    result = await asyncio.wait_for(tool.ainvoke(topic), timeout=6.0)
-                except Exception:
-                    continue
-            snippets.append(str(result)[:500])
+    async def run_tools_for_round(
+        self,
+        *,
+        planned_tools: List[str],
+        topic: str,
+        all_answers: List[Answer],
+    ) -> List[ToolInsight]:
+        return await self._insight_tools.run_tools(
+            planned_tools=planned_tools,
+            topic=topic,
+            all_answers=all_answers,
+        )
 
-        return "\n".join(snippets)
+    @staticmethod
+    def render_tool_context(insights: List[ToolInsight]) -> str:
+        return InsightToolsService.render_context(insights)
 
     async def generate_initial_questions(self, goal: str, topic: str) -> list[str]:
         prompt = (
@@ -115,13 +127,13 @@ class LLMService:
         all_answers: List[Answer],
         round_summaries: List[str],
         next_round: int,
+        tool_context: str = "",
     ) -> list[str]:
         previous_questions = [a.question_text for a in all_answers]
         answer_dump = "\n".join(
             [f"- {a.question_text}: {a.audio_transcript}" for a in all_answers]
         )
         summary_dump = "\n".join(round_summaries)
-        research = await self._research_context(topic)
         prompt = (
             "На основе ответов и summary создай ровно 3 уточняющих вопроса. "
             "Новые вопросы не должны дублировать старые. "
@@ -131,7 +143,7 @@ class LLMService:
             f"Раунд: {next_round}\n"
             f"Summary: {summary_dump}\n"
             f"Ответы: {answer_dump}\n"
-            f"Внешний контекст (MCP Tavily/HF): {research}\n"
+            f"{tool_context}\n"
         )
         response_text = await self._invoke_text(prompt)
         if response_text:
@@ -159,6 +171,38 @@ class LLMService:
 
         return response_text
 
+    async def generate_mock_answers(
+        self,
+        *,
+        goal: str,
+        topic: str,
+        round_number: int,
+        questions: List[str],
+    ) -> list[str]:
+        question_dump = "\n".join([f"{idx + 1}. {q}" for idx, q in enumerate(questions)])
+        prompt = (
+            "Ты играешь роль респондента интервью. "
+            "Сгенерируй реалистичные короткие ответы на каждый вопрос (1-3 предложения). "
+            "Верни строго JSON-массив строк той же длины, что и список вопросов, без комментариев.\n"
+            f"Цель интервью: {goal}\n"
+            f"Тема: {topic}\n"
+            f"Раунд: {round_number}\n"
+            f"Вопросы:\n{question_dump}\n"
+        )
+        response_text = await self._invoke_text(prompt)
+        if response_text:
+            parsed = self._parse_questions(response_text)
+            if len(parsed) >= len(questions):
+                return parsed[: len(questions)]
+
+        fallback = []
+        for idx, question in enumerate(questions, start=1):
+            fallback.append(
+                f"По вопросу {idx}: для темы '{topic}' приоритетом считаем измеримый результат и реалистичный план выполнения. "
+                f"Уточним детали после пилота. ({self._shorten(question, limit=80)})"
+            )
+        return fallback[: len(questions)]
+
     def ensure_distinct_round_summary(
         self,
         round_number: int,
@@ -182,10 +226,10 @@ class LLMService:
         topic: str,
         answers: List[Answer],
         round_summaries: List[str],
+        tool_context: str = "",
     ) -> list[ChecklistItem]:
         answers_dump = "\n".join([f"- {a.question_text}: {a.audio_transcript}" for a in answers])
         summary_dump = "\n".join(round_summaries)
-        research = await self._research_context(topic)
 
         prompt = (
             "Построй итоговый checklist в JSON. Формат: "
@@ -194,7 +238,7 @@ class LLMService:
             f"Цель: {goal}\nТема: {topic}\n"
             f"Summary: {summary_dump}\n"
             f"Ответы:\n{answers_dump}\n"
-            f"Внешний контекст (MCP Tavily/HF): {research}\n"
+            f"{tool_context}\n"
             "Верни только JSON-массив."
         )
 

app/storage/job_store.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import time
+from typing import Dict, Optional
+
+from app.models.job import JobResult, JobStatus, JobStatusResponse, JobStep
+
+
+DEFAULT_STEP_ETAS: dict[str, int] = {
+    "transcribe_1": 6,
+    "transcribe_2": 6,
+    "transcribe_3": 6,
+    "analyze_round": 8,
+    "tool_planning": 3,
+    "tool_execution": 5,
+    "generate_next_questions": 6,
+    "finalize": 10,
+}
+
+STEP_LABELS: dict[str, str] = {
+    "transcribe_1": "Транскрибация ответа 1/3",
+    "transcribe_2": "Транскрибация ответа 2/3",
+    "transcribe_3": "Транскрибация ответа 3/3",
+    "analyze_round": "Анализ ответов раунда",
+    "tool_planning": "Планирование вызова инструментов",
+    "tool_execution": "Выполнение инструментов",
+    "generate_next_questions": "Генерация следующих вопросов",
+    "finalize": "Генерация финального резюме и чеклиста",
+}
+
+
+class JobRecord:
+    def __init__(self, job_id: str, session_id: str, steps: list[JobStep]) -> None:
+        self.job_id = job_id
+        self.session_id = session_id
+        self.status: JobStatus = "queued"
+        self.current_step: Optional[str] = None
+        self.steps = steps
+        self.error: Optional[str] = None
+        self.result: Optional[JobResult] = None
+        self._started_at = time.monotonic()
+        self._step_started_at: Optional[float] = None
+
+    def _eta_left(self) -> int:
+        remaining = 0.0
+        for step in self.steps:
+            if step.status == "completed":
+                continue
+            if step.status == "running" and self._step_started_at is not None:
+                elapsed = max(0.0, time.monotonic() - self._step_started_at)
+                remaining += max(0.0, step.eta_seconds - elapsed)
+            else:
+                remaining += step.eta_seconds
+        return int(round(remaining))
+
+    def _progress_pct(self) -> int:
+        if not self.steps:
+            return 0
+        done = sum(1 for step in self.steps if step.status == "completed")
+        if self.status == "completed":
+            return 100
+        return int((done / len(self.steps)) * 100)
+
+    def as_response(self) -> JobStatusResponse:
+        return JobStatusResponse(
+            job_id=self.job_id,
+            session_id=self.session_id,
+            status=self.status,
+            current_step=self.current_step,
+            steps=self.steps,
+            eta_seconds_left=self._eta_left(),
+            progress_pct=self._progress_pct(),
+            error=self.error,
+            result=self.result,
+        )
+
+
+class JobStore:
+    def __init__(self) -> None:
+        self._jobs: Dict[str, JobRecord] = {}
+        self._step_etas = dict(DEFAULT_STEP_ETAS)
+
+    def _step_eta(self, key: str) -> int:
+        return int(self._step_etas.get(key, 5))
+
+    def create(self, job_id: str, session_id: str, step_keys: list[str]) -> JobRecord:
+        steps = [
+            JobStep(
+                key=step_key,
+                label=STEP_LABELS.get(step_key, step_key),
+                eta_seconds=self._step_eta(step_key),
+            )
+            for step_key in step_keys
+        ]
+        record = JobRecord(job_id=job_id, session_id=session_id, steps=steps)
+        self._jobs[job_id] = record
+        return record
+
+    def get(self, job_id: str) -> Optional[JobRecord]:
+        return self._jobs.get(job_id)
+
+    def mark_running(self, job_id: str) -> None:
+        record = self._jobs[job_id]
+        record.status = "running"
+
+    def mark_step_running(self, job_id: str, step_key: str) -> None:
+        record = self._jobs[job_id]
+        record.current_step = step_key
+        record._step_started_at = time.monotonic()
+        for step in record.steps:
+            if step.key == step_key:
+                step.status = "running"
+                break
+
+    def mark_step_completed(self, job_id: str, step_key: str) -> None:
+        record = self._jobs[job_id]
+        duration = 0.0
+        if record._step_started_at is not None:
+            duration = max(0.0, time.monotonic() - record._step_started_at)
+        for step in record.steps:
+            if step.key == step_key:
+                step.status = "completed"
+                if duration > 0:
+                    prev = float(self._step_etas.get(step.key, step.eta_seconds))
+                    self._step_etas[step.key] = max(1, int(round(prev * 0.75 + duration * 0.25)))
+                break
+        record._step_started_at = None
+
+    def mark_failed(self, job_id: str, error: str) -> None:
+        record = self._jobs[job_id]
+        record.status = "failed"
+        record.error = error
+        if record.current_step:
+            for step in record.steps:
+                if step.key == record.current_step and step.status == "running":
+                    step.status = "failed"
+                    break
+
+    def mark_completed(self, job_id: str, result: JobResult) -> None:
+        record = self._jobs[job_id]
+        record.status = "completed"
+        record.result = result
+        record.current_step = None
+        for step in record.steps:
+            if step.status == "running":
+                step.status = "completed"

tests/test_api_flow.py

@@ -1,10 +1,22 @@
 import base64
+import time
 
 
 def _fake_webm_b64() -> str:
     return base64.b64encode(b"RIFF....FAKEAUDIO").decode("utf-8")
 
 
+def _wait_job_completed(client, job_id: str, max_attempts: int = 300):
+    for _ in range(max_attempts):
+        status = client.get(f"/api/session/jobs/{job_id}")
+        assert status.status_code == 200
+        payload = status.json()
+        if payload["status"] in {"completed", "failed"}:
+            return payload
+        time.sleep(0.01)
+    raise AssertionError("submit job did not finish in time")
+
+
 def _complete_session(client):
     start = client.post(
         "/api/session/start",
@@ -27,7 +39,13 @@ def _complete_session(client):
         }
         submit = client.post(f"/api/session/{session_id}/submit", json=payload)
         assert submit.status_code == 200
-        payload = submit.json()
+        accepted = submit.json()
+        assert accepted["job_id"]
+
+        completed = _wait_job_completed(client, accepted["job_id"])
+        assert completed["status"] == "completed"
+        payload = completed["result"]
+        assert payload
         assert payload["round_summary"]
 
         if expected_round < 3:
@@ -45,6 +63,46 @@ def _complete_session(client):
     return session_id
 
 
+def _complete_session_mock(client):
+    start = client.post(
+        "/api/session/start",
+        json={
+            "goal": "Быстрый тест mock режима",
+            "topic": "Турнир по теннису",
+            "mock_mode": True,
+        },
+    )
+    assert start.status_code == 200
+    session = start.json()
+    assert session["mock_mode"] is True
+    session_id = session["session_id"]
+    questions = session["questions"]
+
+    for _expected_round in [1, 2, 3]:
+        mock_answers = client.post(f"/api/session/{session_id}/mock-answers")
+        assert mock_answers.status_code == 200
+        mock_payload = mock_answers.json()
+        assert len(mock_payload["answers"]) == 3
+
+        question_ids = [q["id"] for q in questions]
+        transcripts = [item["transcript"] for item in mock_payload["answers"]]
+        submit = client.post(
+            f"/api/session/{session_id}/submit",
+            json={"question_ids": ",".join(question_ids), "transcripts": transcripts},
+        )
+        assert submit.status_code == 200
+        accepted = submit.json()
+        completed = _wait_job_completed(client, accepted["job_id"])
+        assert completed["status"] == "completed"
+        result = completed["result"]
+        assert result
+        if result["is_complete"]:
+            break
+        questions = result["questions"]
+
+    return session_id
+
+
 def test_health(client):
     res = client.get("/health")
     assert res.status_code == 200
@@ -61,6 +119,7 @@ def test_full_9_question_flow_and_results(client):
     results_payload = results.json()
     assert results_payload["is_complete"] is True
     assert len(results_payload["checklist"]) >= 1
+    assert len(results_payload["tool_insights"]) >= 1
     assert "Чеклист созвона" in results_payload["markdown"]
     assert results_payload["portrait"] is not None
     assert 1 <= results_payload["portrait"]["emotional_stability"] <= 10
@@ -89,3 +148,12 @@ def test_transcribe_preview(client):
     )
     assert res.status_code == 200
     assert "mock transcript" in res.json()["transcript"]
+
+
+def test_mock_mode_autogenerated_answers_flow(client):
+    session_id = _complete_session_mock(client)
+    results = client.get(f"/api/session/{session_id}/results")
+    assert results.status_code == 200
+    payload = results.json()
+    assert payload["is_complete"] is True
+    assert len(payload["checklist"]) >= 1

tests/test_preflight_unittest.py

@@ -1,6 +1,7 @@
 import os
 import unittest
 import base64
+import time
 
 from fastapi.testclient import TestClient
 
@@ -21,6 +22,18 @@ def fake_webm_b64() -> str:
     return base64.b64encode(b"RIFF....FAKEAUDIO").decode("utf-8")
 
 
+def wait_job_completed(client, job_id: str, max_attempts: int = 300):
+    for _ in range(max_attempts):
+        status = client.get(f"/api/session/jobs/{job_id}")
+        if status.status_code != 200:
+            raise AssertionError(f"Failed to fetch job status for {job_id}")
+        payload = status.json()
+        if payload["status"] in {"completed", "failed"}:
+            return payload
+        time.sleep(0.01)
+    raise AssertionError("submit job did not finish in time")
+
+
 class PreflightFlowTest(unittest.TestCase):
     def setUp(self) -> None:
         self._client_cm = TestClient(app)
@@ -62,7 +75,11 @@ class PreflightFlowTest(unittest.TestCase):
             submit = self.client.post(f"/api/session/{session_id}/submit", json=payload)
 
             self.assertEqual(submit.status_code, 200)
-            payload = submit.json()
+            accepted = submit.json()
+            self.assertTrue(accepted["job_id"])
+            job_done = wait_job_completed(self.client, accepted["job_id"])
+            self.assertEqual(job_done["status"], "completed")
+            payload = job_done["result"]
             self.assertTrue(payload["round_summary"])
 
             if expected_round < 3:
@@ -82,6 +99,7 @@ class PreflightFlowTest(unittest.TestCase):
         results_payload = results.json()
         self.assertTrue(results_payload["is_complete"])
         self.assertGreaterEqual(len(results_payload["checklist"]), 1)
+        self.assertGreaterEqual(len(results_payload["tool_insights"]), 1)
         self.assertIn("Чеклист созвона", results_payload["markdown"])
         self.assertIsNotNone(results_payload["portrait"])
         self.assertGreaterEqual(results_payload["portrait"]["emotional_stability"], 1)