feat(R08): split ScheduleTaskTab, FolderTab, DashboardTab, StructureGraphView

Team Hoa, EPIC R08 (UI/Application Separation) - Team Hoa scope only
(R08-T11 -> T14; R08-T01->T10 belong to Team Duy/Team Nam).

- R08-T11: ui/schedule_task_tab.py (795 lines) -> presentation/scheduling/
  {kanban_board_widget,calendar_view_widget,ai_task_creator_dialog,
  ai_task_import_dialog,run_history_dialog}.py + schedule_task_tab.py
  shell. Kanban CRUD/drag-drop now goes through
  application/scheduling/task_application_service.py (R07-T04) instead of
  ~30 lines of inline if/elif per drag target.
- R08-T12: ui/folder_tab.py (1587 lines, the largest of the four) ->
  presentation/folder/{workspace_file_tree,document_preview_manager,
  code_editor,office_document_renderer,ai_file_editor_dialog,
  ai_edit_model_resolver,ai_edit_pipeline}.py + folder_tab.py shell.
  Closes the R06-T05 loop: FileWorkspaceService existed since R06 with
  zero production call sites (confirmed by grep); every plain-text write
  (save/create/write_content) now goes through it, gaining path
  containment and a Python-syntax warning the original code never had.
  Pure helpers (_read_text, _is_probably_text, _pptx_available,
  _split_code_block, _parse_ai_output) moved to
  application/workspaces/{file_preview_helpers,ai_edit_output}.py.
- R08-T13: ui/dashboard_tab.py (437 lines) -> presentation/dashboard/
  {token_usage_card_widget,usage_chart_widget,habits_widget}.py +
  dashboard_tab.py shell, backed by a new
  application/monitoring/dashboard_query_service.py (pricing/period/
  summary queries the three widgets used to each recompute separately).
  Directory-ownership note left in the checklist for Team Nam.
- R08-T14: ui/structure_graph_view.py (1035 lines) ->
  presentation/graph/{graph_scene_items,graph_renderer,
  graph_messages_view,graph_qa_widget}.py + structure_graph_view.py
  shell. Extraction helpers (_pdf_to_markdown, _extract_file_contents)
  moved to application/workspaces/graph_index_service.py (pure Python).
  Renderer and Q&A panel talk only through signals
  (node_selected/graph_rendered/raw_json_ready/project_changed) - neither
  imports the other.
- presentation/shared/web_engine_support.py: HAS_WEB_ENGINE, previously
  duplicated (folder_tab imported it FROM structure_graph_view.py) - now
  one shared flag instead of one screen importing another screen's module.

All four old ui/*.py files deleted; app.py and ui/workspace_tab.py updated
to the new import paths (each god-file only had 1-2 real construction
sites, so import sites were updated directly rather than kept as a
strangler-fig shim - unlike core/tools.py at R05, which had dozens).

pytest: 377 pass (+94 vs the R07 baseline of 328; same 4 pre-existing
failures as the R05/R06 baseline, unrelated to this work).
scripts/check_imports.py: PASS. python -c "import cowork_local.app": OK.
Every new file < 400 lines (largest: graph_renderer.py, 391).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

application/workspaces/__init__.py

@@ -1,5 +1,17 @@
-"""Workspace file operations for non-agent-loop callers (EPIC R06)."""
+"""Workspace file operations for non-agent-loop callers (EPIC R06, R08)."""
 
+from .ai_edit_output import parse_ai_output, split_code_block
+from .file_preview_helpers import is_probably_text, pptx_available, read_text
 from .file_workspace_service import FileWorkspaceService
+from .graph_index_service import extract_file_contents, pdf_to_markdown
 
-__all__ = ["FileWorkspaceService"]
+__all__ = [
+    "FileWorkspaceService",
+    "read_text",
+    "is_probably_text",
+    "pptx_available",
+    "split_code_block",
+    "parse_ai_output",
+    "pdf_to_markdown",
+    "extract_file_contents",
+]

application/workspaces/ai_edit_output.py

@@ -0,0 +1,40 @@
+"""Parse an AI file-edit reply into its parts (R08-T12, moved out of
+``ui/folder_tab.py`` — that file's module-level ``_split_code_block``/
+``_parse_ai_output``, lines 1536-1562 of the original 1587-line file). Pure
+string parsing, no Qt — used by ``presentation/folder/ai_file_editor_dialog.py``
+to turn a model's raw reply into a proposed edit.
+"""
+from __future__ import annotations
+
+import re
+from typing import List, Optional, Tuple
+
+
+def split_code_block(text: str) -> Tuple[Optional[str], str]:
+    """Split an AI reply into ``(file_content, summary)``. ``file_content``
+    is the first fenced code block (the edited file); ``summary`` is any
+    prose before it. Returns ``(None, text)`` when there's no code block."""
+    m = re.search(r"```[^\n]*\n(.*?)```", text or "", re.DOTALL)
+    if not m:
+        return None, (text or "")
+    return m.group(1), (text[:m.start()].strip())
+
+
+def parse_ai_output(text: str) -> Tuple[Optional[str], Optional[str], str, List[Tuple[str, str]]]:
+    """Parse an AI edit reply into ``(target, content, summary, image_gens)``.
+    ``FILE: <path>`` names a NEW file to create; ``IMAGE_GEN: <prompt> =>
+    <path>`` lines request generated illustration images (relative paths)."""
+    content, summary = split_code_block(text)
+    target = None
+    m = re.search(r"(?mi)^\s*FILE:\s*(.+?)\s*$", text or "")
+    if m:
+        target = m.group(1).strip().strip("`\"'")
+    image_gens = []
+    for gm in re.finditer(r"(?mi)^\s*IMAGE_GEN:\s*(.+?)\s*=>\s*(\S+)\s*$", text or ""):
+        image_gens.append((gm.group(1).strip(), gm.group(2).strip().strip("`\"'")))
+    # Strip the directive lines out of the shown summary.
+    summary = re.sub(r"(?mi)^\s*(FILE|IMAGE_GEN):\s*.+?$", "", summary).strip()
+    return target, content, summary, image_gens
+
+
+__all__ = ["split_code_block", "parse_ai_output"]

application/workspaces/file_preview_helpers.py

@@ -0,0 +1,54 @@
+"""Pure helpers for previewing a file (R08-T12, moved out of
+``ui/folder_tab.py`` — that file's module-level functions
+``_read_text``/``_is_probably_text``/``_pptx_available``, lines 1519-1533 and
+1565-1587 of the original 1587-line file). No Qt, no widget state — the
+"is this file text? is pptx editing available?" questions the preview
+manager asks before it decides how to render something.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+_PPTX_READY = None   # cached: pptx-editing library available (after auto-install)
+
+
+def pptx_available() -> bool:
+    """True when python-pptx is importable. If it's MISSING, auto-download &
+    install it (via deps.ensure_module) so pptx editing 'just works' — cached
+    so the (one-time) install is attempted only once."""
+    global _PPTX_READY
+    if _PPTX_READY is None:
+        try:
+            from cowork_local.core.deps import ensure_module
+
+            _PPTX_READY = ensure_module("pptx", "python-pptx") is not None
+        except Exception:  # noqa: BLE001
+            _PPTX_READY = False
+    return _PPTX_READY
+
+
+def read_text(path: str) -> str:
+    try:
+        return Path(path).read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        return f"[could not read file: {exc}]"
+
+
+def is_probably_text(path: str) -> bool:
+    try:
+        with open(path, "rb") as f:
+            chunk = f.read(4096)
+    except OSError:
+        return False
+    if b"\x00" in chunk:
+        return False
+    try:
+        chunk.decode("utf-8")
+        return True
+    except UnicodeDecodeError:
+        # Latin-ish text still edits fine via errors="replace"; only reject on
+        # a hard binary signal (NUL above), so most source files pass.
+        return True
+
+
+__all__ = ["pptx_available", "read_text", "is_probably_text"]

application/workspaces/graph_index_service.py

@@ -0,0 +1,91 @@
+"""Temporary file-content extraction for Graph-RAG Q&A (R08-T14, moved out
+of ``ui/structure_graph_view.py`` — that file's module-level
+``_pdf_to_markdown``/``_extract_file_contents``, lines 964-1034 of the
+original 1035-line file). Runs inside the ask worker's job function so the
+answer is synthesized from real file content, not just the graph structure.
+
+Pure Python: no Qt. Best-effort throughout (never raises) — a failed
+extraction degrades to "no content for this file", not a broken Q&A turn.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+def pdf_to_markdown(pdf_path: str, out_dir: str) -> Optional[str]:
+    """Convert a PDF to Markdown with opendataloader-pdf when available
+    (richer structure than a plain text dump). Best-effort — returns None
+    if the package isn't installed or the call fails, so the caller falls
+    back to ``core/doc_extract.py``."""
+    try:
+        import opendataloader_pdf  # optional; auto-installed elsewhere if present
+    except Exception:  # noqa: BLE001
+        try:
+            from cowork_local.core.deps import ensure_module
+            if ensure_module("opendataloader_pdf", "opendataloader-pdf") is None:
+                return None
+            import opendataloader_pdf  # noqa: F811
+        except Exception:  # noqa: BLE001
+            return None
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    for call in (
+        lambda: opendataloader_pdf.convert(input_path=[str(pdf_path)], output_dir=str(out),
+                                           generate_markdown=True),
+        lambda: opendataloader_pdf.convert(input_path=str(pdf_path), output_dir=str(out)),
+        lambda: opendataloader_pdf.convert(str(pdf_path), str(out)),
+    ):
+        try:
+            call()
+            break
+        except TypeError:
+            continue
+        except Exception:  # noqa: BLE001
+            return None
+    mds = list(out.rglob(Path(pdf_path).stem + "*.md")) or list(out.rglob("*.md"))
+    for md in mds:
+        try:
+            return md.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+    return None
+
+
+def extract_file_contents(paths: List[str], cache: Dict[str, str], tmp_dir: str,
+                          max_files: int = 15, max_total: int = 120_000
+                          ) -> Tuple[str, Dict[str, str]]:
+    """Read the ACTUAL content of ``paths`` (PDF -> markdown via
+    opendataloader when available, else ``doc_extract`` for office/pdf/
+    text). Returns ``(block, cache)`` — ``block`` is the concatenated
+    content for the prompt (bounded), ``cache`` maps path -> text for
+    reuse. Never raises."""
+    from cowork_local.core import doc_extract
+
+    cache = dict(cache or {})
+    parts, total = [], 0
+    for p in paths[:max_files]:
+        if total >= max_total:
+            break
+        text = cache.get(p)
+        if text is None:
+            try:
+                if Path(p).suffix.lower() == ".pdf":
+                    text = pdf_to_markdown(p, tmp_dir)
+                    if not text:
+                        text, _n = doc_extract.extract_text(p)
+                else:
+                    text, _n = doc_extract.extract_text(p)
+            except Exception:  # noqa: BLE001
+                text = ""
+            cache[p] = text or ""
+        text = cache.get(p) or ""
+        if not text:
+            continue
+        chunk = text[: max(0, max_total - total)]
+        total += len(chunk)
+        parts.append(f'--- {Path(p).name} ({p}) ---\n{chunk}')
+    return ("\n\n".join(parts), cache)
+
+
+__all__ = ["pdf_to_markdown", "extract_file_contents"]