clouds-coder 2026.3.25__tar.gz → 2026.3.28__tar.gz

{clouds_coder-2026.3.25 → clouds_coder-2026.3.28}/Clouds_Coder.py

@@ -27,6 +27,7 @@ import shlex
 import socket
 import subprocess
 import sys
+import tarfile
 import threading
 import time
 import traceback
@@ -103,7 +104,7 @@ CODE_LIBRARY_DIRNAME = "Code_Library"
 CODE_ADMIN_PORT_OFFSET = 3
 RAG_CHUNK_CHARS = 1200
 RAG_CHUNK_OVERLAP = 180
-RAG_MAX_CHUNKS_PER_DOC = 200
+RAG_MAX_CHUNKS_PER_DOC = 500
 CODE_CHUNK_CHARS = 1800
 CODE_CHUNK_OVERLAP = 120
 CODE_MAX_CHUNKS_PER_DOC = 260
@@ -152,7 +153,7 @@ MIN_AGENT_ROUNDS = 8
 MAX_AGENT_ROUNDS_CAP = 400
 REPEATED_TOOL_LOOP_THRESHOLD = 2
 BASH_READ_LOOP_THRESHOLD = 3
-HARD_BREAK_TOOL_ERROR_THRESHOLD = 3
+HARD_BREAK_TOOL_ERROR_THRESHOLD = 20
 HARD_BREAK_RECOVERY_ROUND_THRESHOLD = 3
 FUSED_FAULT_BREAK_THRESHOLD = 3
 STALL_SEVERITY_ESCALATION_THRESHOLD = 5
@@ -454,7 +455,7 @@ PLAN_MODE_USER_CHOICES = ("auto", "on", "off")
 TASK_PHASES = ("research", "design", "implement", "test", "review", "deploy")
 TASK_PHASE_ROUTING = {
     "research": "explorer",
-    "design": "explorer",
+    "design": "developer",
     "implement": "developer",
     "test": "developer",
     "review": "reviewer",
@@ -479,6 +480,8 @@ EXPLORER_STALL_THRESHOLD = 3  # consecutive same-target delegations before force
 DEVELOPER_EDIT_STALL_THRESHOLD = 3  # consecutive edit_file failures on same file before forced strategy change
 PLAN_MODE_MANAGER_SYNTHESIS_MAX_TOKENS = 4096
 PLAN_MODE_MAX_OPTIONS = 3
+PLAN_FILE_RELATIVE_PATH = ".clouds_coder/plan.md"
+PLAN_BUBBLE_MAX_CHARS = 3800  # margin under ASSISTANT_MESSAGE_EVENT_MAX_CHARS (4000)
 PLAN_MODE_RESEARCH_TOOL_ALLOWLIST = {
     "bash", "read_file", "context_recall", "task_get", "task_list",
     "check_background", "read_from_blackboard", "write_to_blackboard",
@@ -974,11 +977,214 @@ OFFLINE_JS_LIB_CATALOG: list[dict[str, object]] = [
         ],
         "match_tokens": ["cdn.tailwindcss.com", "@tailwindcss/browser", "tailwindcss"],
     },
+    {
+        "id": "mathjax",
+        "filename": "tex-mml-chtml.js",
+        "relative_path": "mathjax/es5/tex-mml-chtml.js",
+        "package_urls": [
+            "https://registry.npmjs.org/mathjax/-/mathjax-3.2.2.tgz",
+        ],
+        "package_install_dir": "mathjax",
+        "package_required_paths": [
+            "package.json",
+            "es5/core.js",
+            "es5/loader.js",
+            "es5/startup.js",
+            "es5/tex-mml-chtml.js",
+        ],
+        "match_tokens": ["mathjax", "tex-mml-chtml.js", "/mathjax@"],
+    },
+    {
+        "id": "katex",
+        "filename": "katex.min.js",
+        "relative_path": "katex/dist/katex.min.js",
+        "package_urls": [
+            "https://registry.npmjs.org/katex/-/katex-0.16.11.tgz",
+        ],
+        "package_install_dir": "katex",
+        "package_required_paths": [
+            "package.json",
+            "dist/katex.min.js",
+            "dist/katex.min.css",
+            "dist/contrib/auto-render.min.js",
+        ],
+        "match_tokens": ["katex", "katex.min.js", "/katex@"],
+    },
+    {
+        "id": "katex_auto_render",
+        "filename": "auto-render.min.js",
+        "relative_path": "katex/dist/contrib/auto-render.min.js",
+        "match_tokens": ["auto-render.min.js", "katex/contrib/auto-render", "katex-auto-render"],
+    },
+    {
+        "id": "html2canvas",
+        "filename": "html2canvas.min.js",
+        "urls": [
+            "https://cdn.jsdelivr.net/npm/html2canvas@1.4.1/dist/html2canvas.min.js",
+            "https://unpkg.com/html2canvas@1.4.1/dist/html2canvas.min.js",
+        ],
+        "match_tokens": ["html2canvas", "html2canvas.min.js"],
+    },
+    {
+        "id": "jspdf",
+        "filename": "jspdf.umd.min.js",
+        "urls": [
+            "https://cdn.jsdelivr.net/npm/jspdf@2.5.1/dist/jspdf.umd.min.js",
+            "https://unpkg.com/jspdf@2.5.1/dist/jspdf.umd.min.js",
+        ],
+        "match_tokens": ["jspdf", "jspdf.umd.min.js"],
+    },
+    {
+        "id": "xlsx",
+        "filename": "xlsx.full.min.js",
+        "urls": [
+            "https://cdn.jsdelivr.net/npm/xlsx@0.18.5/dist/xlsx.full.min.js",
+            "https://unpkg.com/xlsx@0.18.5/dist/xlsx.full.min.js",
+        ],
+        "match_tokens": ["xlsx", "xlsx.full.min.js", "sheetjs"],
+    },
+    {
+        "id": "jszip",
+        "filename": "jszip.min.js",
+        "relative_path": "node_modules/jszip/dist/jszip.min.js",
+        "package_urls": [
+            "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
+        ],
+        "package_install_dir": "node_modules/jszip",
+        "package_required_paths": [
+            "package.json",
+            "dist/jszip.min.js",
+        ],
+        "package_postprocess": "jszip-main-to-dist",
+        "match_tokens": ["jszip", "jszip.min.js"],
+    },
+    {
+        "id": "pptxgenjs",
+        "filename": "pptxgen.bundle.js",
+        "relative_path": "pptxgenjs/dist/pptxgen.bundle.js",
+        "package_urls": [
+            "https://registry.npmjs.org/pptxgenjs/-/pptxgenjs-4.0.1.tgz",
+        ],
+        "package_install_dir": "pptxgenjs",
+        "package_required_paths": [
+            "package.json",
+            "dist/pptxgen.bundle.js",
+            "dist/pptxgen.cjs.js",
+            "dist/pptxgen.es.js",
+            "dist/pptxgen.min.js",
+        ],
+        "match_tokens": ["pptxgenjs", "pptxgen.bundle.js", "pptxgen.cjs.js", "pptxgen.es.js", "pptxgen.min.js", "jszip.min.js"],
+    },
+    {
+        "id": "pptxgenjs_bundle",
+        "filename": "pptxgen.bundle.js",
+        "relative_path": "pptxgenjs/dist/pptxgen.bundle.js",
+        "match_tokens": ["pptxgenjs", "pptxgen.bundle.js", "pptxgen.bundle"],
+    },
+    {
+        "id": "pptxgenjs_cjs",
+        "filename": "pptxgen.cjs.js",
+        "relative_path": "pptxgenjs/dist/pptxgen.cjs.js",
+        "match_tokens": ["pptxgenjs", "pptxgen.cjs.js", "pptxgen.cjs"],
+    },
+    {
+        "id": "pptxgenjs_es",
+        "filename": "pptxgen.es.js",
+        "relative_path": "pptxgenjs/dist/pptxgen.es.js",
+        "match_tokens": ["pptxgenjs", "pptxgen.es.js", "pptxgen.es"],
+    },
+    {
+        "id": "pptxgenjs_min",
+        "filename": "pptxgen.min.js",
+        "relative_path": "pptxgenjs/dist/pptxgen.min.js",
+        "match_tokens": ["pptxgenjs", "pptxgen.min.js", "pptxgen.min"],
+    },
 ]
 OFFLINE_JS_LIB_INDEX_FILE = "index.json"
 OFFLINE_JS_LIB_README_FILE = "README.md"
 
 
+def _normalize_js_lib_asset_ref(value: str) -> str:
+    raw = str(value or "").replace("\\", "/").strip()
+    if not raw:
+        return ""
+    raw = raw.lstrip("/")
+    pure = PurePosixPath(raw)
+    parts: list[str] = []
+    for part in pure.parts:
+        if part in {"", "."}:
+            continue
+        if part == "..":
+            return ""
+        parts.append(part)
+    return "/".join(parts)
+
+
+def _resolve_js_lib_asset_path(js_root: Path, asset_ref: str) -> Path | None:
+    rel = _normalize_js_lib_asset_ref(asset_ref)
+    if not rel:
+        return None
+    exact = (js_root / rel).resolve()
+    try:
+        if exact.is_file() and exact.is_relative_to(js_root):
+            return exact
+    except Exception:
+        pass
+    basename = _safe_js_filename(Path(rel).name, "lib.js")
+    candidates: list[Path] = []
+    try:
+        for fp in js_root.rglob(basename):
+            try:
+                resolved = fp.resolve()
+            except Exception:
+                continue
+            if resolved.is_file():
+                try:
+                    if resolved.is_relative_to(js_root):
+                        candidates.append(resolved)
+                except Exception:
+                    continue
+    except Exception:
+        return None
+    if not candidates:
+        return None
+    candidates.sort(key=lambda p: (len(p.relative_to(js_root).parts), p.relative_to(js_root).as_posix()))
+    return candidates[0]
+
+
+def _discover_extra_js_lib_files(js_root: Path, known_relative_paths: set[str]) -> list[dict]:
+    rows: list[dict] = []
+    if not js_root.exists():
+        return rows
+    seen: set[str] = set()
+    for fp in sorted(js_root.rglob("*")):
+        if not fp.is_file() or fp.name in {".DS_Store", OFFLINE_JS_LIB_INDEX_FILE, OFFLINE_JS_LIB_README_FILE}:
+            continue
+        if fp.suffix.lower() not in {".js", ".mjs", ".cjs"}:
+            continue
+        rel = fp.relative_to(js_root).as_posix()
+        if rel in known_relative_paths or rel in seen:
+            continue
+        seen.add(rel)
+        stem = fp.stem.replace(".min", "").replace(".umd", "").replace(".bundle", "")
+        rows.append(
+            {
+                "id": f"local:{stem or fp.name}",
+                "filename": fp.name,
+                "relative_path": rel,
+                "available": True,
+                "size": int(fp.stat().st_size),
+                "sha256": _sha256_file(fp),
+                "source": "existing-local",
+                "error": "",
+                "match_tokens": [fp.name.lower(), stem.lower(), rel.lower()],
+                "urls": [],
+                "catalog": False,
+            }
+        )
+    return rows
+
+
 def normalize_ui_language(raw: str | None) -> str:
     key = str(raw or "").strip()
     if key in UI_LANGUAGE_LABELS:
@@ -1105,6 +1311,7 @@ def _detect_os_shell_instruction() -> str:
             "Package manager is 'brew'. "
             "Environment variables WORKSPACE_ROOT, SESSION_ROOT, and SKILLS_ROOT are available. "
             "Virtual aliases '/workspace/...' and '/skills/...' are supported in shell commands and rewritten to real paths before execution. "
+            "Virtual alias '/js_lib/...' maps to the offline JS libraries root ($JS_LIB_ROOT) and is also supported in file tools. "
             "Do NOT assume Linux-specific paths like /proc or /etc/os-release exist. "
             "IMPORTANT: The workspace path contains spaces. Always use relative paths "
             "(e.g., 'ls uploaded/' not 'ls /full/absolute/path/uploaded/'). "
@@ -1253,6 +1460,28 @@ def extract_ui_style_setting(raw: object) -> str | None:
     return None
 
 
+def extract_js_lib_download_setting(raw: object) -> bool | None:
+    """Read download_js_lib flag from config dict.
+    Keys accepted: download_js_lib / js_lib_download / enable_js_lib_download
+    Sections searched: top-level, then 'startup' / 'offline' / 'web_ui'.
+    Returns True/False, or None if key absent (caller uses default=True).
+    """
+    if not isinstance(raw, dict):
+        return None
+    keys = ("download_js_lib", "js_lib_download", "enable_js_lib_download", "offline_js_download")
+    for key in keys:
+        if key in raw:
+            return _to_bool_like(raw.get(key), default=True)
+    for section_key in ("startup", "offline", "web_ui", "ui"):
+        section = raw.get(section_key)
+        if not isinstance(section, dict):
+            continue
+        for key in keys:
+            if key in section:
+                return _to_bool_like(section.get(key), default=True)
+    return None
+
+
 def default_multimodal_capabilities() -> dict[str, bool]:
     return {
         "input_image": False,
@@ -1618,20 +1847,194 @@ def _download_http_bytes(url: str, timeout: float = 25.0) -> tuple[bytes, str]:
 def offline_js_lib_root(workdir: Path = WORKDIR) -> Path:
     return (workdir / "js_lib").resolve()
 
+def _offline_js_entry_relative_path(entry: dict[str, object], fallback_name: str) -> str:
+    rel = _normalize_js_lib_asset_ref(str(entry.get("relative_path", "") or ""))
+    if rel:
+        return rel
+    return _safe_js_filename(fallback_name, fallback_name)
+
+def _archive_member_relative_path(name: str) -> str:
+    raw = _normalize_js_lib_asset_ref(name)
+    if not raw:
+        return ""
+    parts = [part for part in PurePosixPath(raw).parts if part not in {"", "."}]
+    while parts and parts[0].lower() == "package":
+        parts = parts[1:]
+    if not parts:
+        return ""
+    return "/".join(parts)
+
+def _path_size_bytes(target: Path) -> int:
+    try:
+        if target.is_file():
+            return int(target.stat().st_size)
+        if not target.exists():
+            return 0
+        total = 0
+        for fp in target.rglob("*"):
+            try:
+                if fp.is_file():
+                    total += int(fp.stat().st_size)
+            except Exception:
+                continue
+        return total
+    except Exception:
+        return 0
+
+def _extract_archive_to_dir(raw: bytes, install_root: Path) -> list[str]:
+    install_root.mkdir(parents=True, exist_ok=True)
+    install_root_resolved = install_root.resolve()
+    written: list[str] = []
+
+    def _write_bytes(rel: str, data: bytes):
+        target = (install_root / rel).resolve()
+        if not target.is_relative_to(install_root_resolved):
+            raise ValueError(f"archive member escapes target dir: {rel}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(data)
+        written.append(rel)
+
+    bio = io.BytesIO(raw)
+    try:
+        if zipfile.is_zipfile(bio):
+            bio.seek(0)
+            with zipfile.ZipFile(bio, "r") as zf:
+                for info in zf.infolist():
+                    if info.is_dir():
+                        continue
+                    rel = _archive_member_relative_path(info.filename)
+                    if not rel:
+                        continue
+                    _write_bytes(rel, zf.read(info))
+            return written
+    except Exception:
+        pass
+
+    with tarfile.open(fileobj=io.BytesIO(raw), mode="r:*") as tf:
+        for member in tf.getmembers():
+            if not member.isfile():
+                continue
+            rel = _archive_member_relative_path(member.name)
+            if not rel:
+                continue
+            extracted = tf.extractfile(member)
+            if extracted is None:
+                continue
+            _write_bytes(rel, extracted.read())
+    return written
+
+def _package_required_paths(entry: dict[str, object]) -> list[str]:
+    rows: list[str] = []
+    for item in entry.get("package_required_paths") or []:
+        rel = _normalize_js_lib_asset_ref(str(item or ""))
+        if rel:
+            rows.append(rel)
+    return rows
+
+def _package_install_ready(install_root: Path, required_paths: list[str]) -> bool:
+    if not install_root.exists():
+        return False
+    if required_paths:
+        return all((install_root / rel).is_file() for rel in required_paths)
+    try:
+        return any(fp.is_file() for fp in install_root.rglob("*"))
+    except Exception:
+        return False
+
+def _postprocess_offline_js_package(entry: dict[str, object], install_root: Path):
+    action = str(entry.get("package_postprocess", "") or "").strip().lower()
+    if action != "jszip-main-to-dist":
+        return
+    pkg_json = (install_root / "package.json").resolve()
+    dist_fp = (install_root / "dist" / "jszip.min.js").resolve()
+    if not pkg_json.exists():
+        if not dist_fp.exists():
+            return
+        obj: dict[str, object] = {
+            "name": "jszip",
+            "version": "offline-local",
+            "main": "./dist/jszip.min.js",
+            "exports": {".": "./dist/jszip.min.js"},
+        }
+    else:
+        try:
+            raw = pkg_json.read_text(encoding="utf-8")
+            loaded = json.loads(raw)
+            if not isinstance(loaded, dict):
+                return
+            obj = loaded
+        except Exception:
+            return
+    changed = False
+    if obj.get("main") != "./dist/jszip.min.js":
+        obj["main"] = "./dist/jszip.min.js"
+        changed = True
+    exports = obj.get("exports")
+    desired_exports = {".": "./dist/jszip.min.js"}
+    if exports != desired_exports:
+        obj["exports"] = desired_exports
+        changed = True
+    if changed or (not pkg_json.exists()):
+        pkg_json.parent.mkdir(parents=True, exist_ok=True)
+        pkg_json.write_text(json_dumps(obj, indent=2), encoding="utf-8")
+
+def _ensure_offline_js_package(root: Path, entry: dict[str, object], force: bool = False) -> tuple[bool, str, str, str]:
+    package_urls = [str(x).strip() for x in (entry.get("package_urls") or []) if str(x).strip()]
+    if not package_urls:
+        return True, "", "", ""
+    install_dir = _normalize_js_lib_asset_ref(str(entry.get("package_install_dir", "") or ""))
+    if not install_dir:
+        install_dir = _normalize_js_lib_asset_ref(str(entry.get("id", "") or "package"))
+    if not install_dir:
+        return False, "missing", "package install dir is empty", ""
+    install_root = (root / install_dir).resolve()
+    if not install_root.is_relative_to(root):
+        return False, "missing", f"package install dir escapes js_lib: {install_dir}", install_dir
+    required_paths = _package_required_paths(entry)
+    if not force and install_root.exists():
+        _postprocess_offline_js_package(entry, install_root)
+        if _package_install_ready(install_root, required_paths):
+            return True, "existing-package", "", install_dir
+        try:
+            if any(fp.is_file() for fp in install_root.rglob("*")):
+                return True, "existing-package", "", install_dir
+        except Exception:
+            pass
+    error = ""
+    source = "missing"
+    for url in package_urls:
+        try:
+            data, _ = _download_http_bytes(url, timeout=90.0)
+            if len(data) < 200:
+                error = f"archive too small from {url}"
+                continue
+            _extract_archive_to_dir(data, install_root)
+            _postprocess_offline_js_package(entry, install_root)
+            if _package_install_ready(install_root, required_paths):
+                return True, url, "", install_dir
+            error = f"package install incomplete from {url}"
+            source = url
+        except Exception as exc:
+            error = trim(str(exc), 220)
+            source = url
+    return False, source, error, install_dir
+
 def _render_offline_js_catalog_md() -> str:
     rows = [
         "# Offline JS Library Catalog",
         "",
         "Pre-fetched common JS libraries for offline HTML deliverables.",
+        "Additional local `.js/.mjs/.cjs` files placed anywhere under `js_lib/` are auto-indexed in `index.json` and can be served by relative path.",
         "",
-        "| id | filename | source urls |",
-        "|---|---|---|",
+        "| id | relative path | file urls | package urls |",
+        "|---|---|---|---|",
     ]
     for row in OFFLINE_JS_LIB_CATALOG:
         lib_id = str(row.get("id", "") or "").strip()
-        filename = str(row.get("filename", "") or "").strip()
+        filename = _offline_js_entry_relative_path(row, str(row.get("filename", "") or lib_id or "lib.js"))
         urls = [str(x).strip() for x in (row.get("urls") or []) if str(x).strip()]
-        rows.append(f"| `{lib_id}` | `{filename}` | {'<br>'.join(urls)} |")
+        package_urls = [str(x).strip() for x in (row.get("package_urls") or []) if str(x).strip()]
+        rows.append(f"| `{lib_id}` | `{filename}` | {'<br>'.join(urls)} | {'<br>'.join(package_urls)} |")
     return "\n".join(rows) + "\n"
 
 def load_offline_js_lib_index(js_root: Path) -> dict:
@@ -1645,26 +2048,78 @@ def load_offline_js_lib_index(js_root: Path) -> dict:
     except Exception:
         return {}
 
-def ensure_offline_js_libs(workdir: Path = WORKDIR, force: bool = False) -> dict:
+def ensure_offline_js_libs(
+    workdir: Path = WORKDIR,
+    force: bool = False,
+    verbose: bool = False,
+    no_connection_deadline: float = 60.0,
+) -> dict:
     root = offline_js_lib_root(workdir)
     root.mkdir(parents=True, exist_ok=True)
     fetched = 0
     available = 0
     missing = 0
+    _dl_start = time.time()
+    _deadline_hit = False
+    total_catalog = len(OFFLINE_JS_LIB_CATALOG)
+    if verbose:
+        print(f"[js_lib] Starting JS library download ({total_catalog} files)...", flush=True)
     rows: list[dict] = []
+    known_relative_paths: set[str] = set()
     for entry in OFFLINE_JS_LIB_CATALOG:
         lib_id = str(entry.get("id", "") or "").strip() or "lib"
         filename = _safe_js_filename(str(entry.get("filename", "") or f"{lib_id}.js"), f"{lib_id}.js")
+        relative_path = _offline_js_entry_relative_path(entry, filename)
         urls = [str(x).strip() for x in (entry.get("urls") or []) if str(x).strip()]
+        package_urls = [str(x).strip() for x in (entry.get("package_urls") or []) if str(x).strip()]
         match_tokens = [str(x).strip().lower() for x in (entry.get("match_tokens") or []) if str(x).strip()]
-        target = root / filename
+        target = (root / relative_path).resolve()
+        if not target.is_relative_to(root):
+            rows.append(
+                {
+                    "id": lib_id,
+                    "filename": filename,
+                    "available": False,
+                    "size": 0,
+                    "sha256": "",
+                    "source": "missing",
+                    "error": f"relative path escapes js_lib: {relative_path}",
+                    "match_tokens": match_tokens,
+                    "urls": urls,
+                    "package_urls": package_urls,
+                    "relative_path": relative_path,
+                    "package_install_dir": "",
+                    "package_required_paths": [],
+                    "package_available": not package_urls,
+                    "package_size": 0,
+                    "catalog": True,
+                }
+            )
+            missing += 1
+            continue
+        known_relative_paths.add(relative_path)
         source = "existing"
         error = ""
-        ok = bool(target.exists() and target.is_file() and target.stat().st_size > 40 and (not force))
-        if not ok:
+        effective_target = target
+        file_ok = bool(target.exists() and target.is_file() and target.stat().st_size > 40 and (not force))
+        if (not file_ok) and (not force):
+            resolved_existing = _resolve_js_lib_asset_path(root, relative_path)
+            if resolved_existing and resolved_existing.exists() and resolved_existing.is_file() and resolved_existing.stat().st_size > 40:
+                effective_target = resolved_existing
+                file_ok = True
+                source = "existing-local"
+        if not file_ok and urls:
+            if fetched == 0 and (time.time() - _dl_start) > no_connection_deadline:
+                _deadline_hit = True
+                if verbose:
+                    print(f"[js_lib] No connection after {no_connection_deadline:.0f}s — skipping remaining downloads.", flush=True)
+                break
+            if verbose:
+                print(f"[js_lib] Downloading {filename}...", flush=True)
             for url in urls:
                 try:
-                    data, _ = _download_http_bytes(url, timeout=35.0)
+                    _timeout = 12.0 if fetched == 0 else 35.0
+                    data, _ = _download_http_bytes(url, timeout=_timeout)
                     if len(data) < 40:
                         error = f"download too small from {url}"
                         continue
@@ -1672,39 +2127,67 @@ def ensure_offline_js_libs(workdir: Path = WORKDIR, force: bool = False) -> dict
                     if "<html" in probe and "<script" not in probe and "tailwind" not in probe:
                         error = f"unexpected html payload from {url}"
                         continue
+                    target.parent.mkdir(parents=True, exist_ok=True)
                     target.write_bytes(data)
-                    ok = True
+                    effective_target = target
+                    file_ok = True
                     source = url
                     fetched += 1
                     break
                 except Exception as exc:
                     error = trim(str(exc), 220)
-            if not ok:
+            if not file_ok:
                 source = "missing"
+        package_ok, package_source, package_error, package_install_dir = _ensure_offline_js_package(root, entry, force=force)
+        if package_urls and package_source and package_source not in {"existing-package", "missing"}:
+            fetched += 1
+        if package_error:
+            error = package_error if not error else f"{error}; {package_error}"
+        ok = bool((file_ok or (not urls)) and package_ok and effective_target.exists() and effective_target.is_file() and effective_target.stat().st_size > 40)
         if ok:
             available += 1
         else:
             missing += 1
+            if package_urls and package_source == "missing" and not source.strip():
+                source = "missing"
+        package_root = (root / package_install_dir).resolve() if package_install_dir else None
         rows.append(
             {
                 "id": lib_id,
                 "filename": filename,
                 "available": ok,
-                "size": int(target.stat().st_size) if target.exists() else 0,
-                "sha256": _sha256_file(target) if target.exists() else "",
-                "source": source,
+                "size": int(effective_target.stat().st_size) if effective_target.exists() else 0,
+                "sha256": _sha256_file(effective_target) if effective_target.exists() else "",
+                "source": source if source != "existing" or file_ok else package_source or source,
                 "error": error,
                 "match_tokens": match_tokens,
                 "urls": urls,
+                "package_urls": package_urls,
+                "relative_path": relative_path,
+                "resolved_path": effective_target.relative_to(root).as_posix() if effective_target.exists() else "",
+                "package_install_dir": package_install_dir,
+                "package_required_paths": _package_required_paths(entry),
+                "package_available": package_ok,
+                "package_size": _path_size_bytes(package_root) if package_root else 0,
+                "package_source": package_source,
+                "catalog": True,
             }
         )
+    extra_rows = _discover_extra_js_lib_files(root, known_relative_paths)
+    rows.extend(extra_rows)
+    if verbose:
+        _status = "skipped (no connection)" if _deadline_hit else f"{fetched} downloaded"
+        print(f"[js_lib] Done: {available}/{len(rows)} available, {_status}.", flush=True)
     payload = {
         "generated_at": int(now_ts()),
         "js_lib_root": str(root),
-        "total": len(OFFLINE_JS_LIB_CATALOG),
+        "total": len(rows),
         "available": available,
         "missing": missing,
         "fetched": fetched,
+        "catalog_total": len(OFFLINE_JS_LIB_CATALOG),
+        "catalog_missing": missing,
+        "extra_local": len(extra_rows),
         "libs": rows,
     }
     (root / OFFLINE_JS_LIB_INDEX_FILE).write_text(json_dumps(payload, indent=2), encoding="utf-8")
@@ -3666,9 +4149,13 @@ class TodoManager:
                 row["owner"] = owner
             if key:
                 row["key"] = key
+            # Preserve parent_step_id for subtask-to-plan-step linkage
+            parent_step_id = trim(str(raw.get("parent_step_id", "") or ""), 20)
+            if parent_step_id:
+                row["parent_step_id"] = parent_step_id
             validated.append(row)
-        if len(validated) > 20:
-            raise ValueError("max 20 todos")
+        if len(validated) > 40:
+            raise ValueError("max 40 todos")
         if validated and not any(x["status"] == "in_progress" for x in validated):
             for row in validated:
                 if row["status"] == "pending":
@@ -4311,6 +4798,7 @@ EMBEDDED_SKILLS_ARCHIVE_FILES = [
     "skills/generated/upload-office-parser/SKILL.md",
     "skills/generated/upload-parsers-capabilities.json",
     "skills/generated/upload-tabular-parser/SKILL.md",
+    "skills/generated/upload-image-parser/SKILL.md",
     "skills/mcp-builder/SKILL.md",
     "skills/pdf/SKILL.md",
     "skills/skills_Gen/SKILL.md",
@@ -4469,6 +4957,36 @@ Use this skill when the user uploads Word/PowerPoint documents and needs content
 ## Notes
 - The backend automatically parses `.doc`, `.docx`, `.ppt`, `.pptx`.
 - If parser dependencies are unavailable, fallback extractor is used (may lose formatting).
+"""
+    image_skill = """---
+name: upload-image-parser
+description: Analyze uploaded image files (PNG/JPG/JPEG/WEBP/GIF/BMP) using model native vision capabilities as the primary method; no OCR tools needed for supported formats.
+---
+
+# Upload Image Parser
+
+Use this skill when the user uploads image files and needs content description, analysis, extraction, or comparison.
+
+## Primary Approach: Model Vision (Multimodal)
+1. Use `read_file` on the uploaded image path — the runtime automatically injects it as a native vision input to the model.
+2. Analyze or describe the image directly with vision capabilities; no external tools required.
+3. Uploaded image paths are under `files/uploaded/` in the session workspace. Check `Uploaded files context` in the system prompt for exact paths.
+
+## Format Notes
+- Native formats (sent directly, no conversion): `.png`, `.jpg`, `.jpeg`, `.webp`, `.gif`
+- Auto-converted formats (runtime handles via Pillow): `.bmp`, `.tiff`, `.tif`, `.heic`, `.heif`, `.avif`
+  - If conversion fails, the runtime returns an error message; use bash fallback below.
+- `.svg` files: runtime returns the SVG markup as text — parse the XML/SVG source directly, do not treat as a raster image.
+
+## Fallback (only if runtime reports vision input unavailable)
+If the model cannot process the image natively (runtime message will say so):
+- OCR text extraction: `bash` → `tesseract <path> stdout`
+- Metadata / dimensions: `bash` → `identify <path>` (ImageMagick)
+- Pixel-level analysis: `bash` → `python3 -c "from PIL import Image; img=Image.open('<path>'); print(img.size, img.mode)"`
+
+## Notes
+- Never attempt text extraction (OCR) on images when vision input is available — use the model's native understanding instead.
+- For multi-image comparison tasks, load each image via `read_file` sequentially; the runtime accumulates them as pending media inputs for the next model call.
 """
     cap_json = json_dumps(
         {
@@ -4479,6 +4997,7 @@ Use this skill when the user uploads Word/PowerPoint documents and needs content
     )
     _write_text_if_changed(generated_root / "upload-tabular-parser" / "SKILL.md", tabular_skill)
     _write_text_if_changed(generated_root / "upload-office-parser" / "SKILL.md", office_skill)
+    _write_text_if_changed(generated_root / "upload-image-parser" / "SKILL.md", image_skill)
     _write_text_if_changed(generated_root / "upload-parsers-capabilities.json", cap_json)
 
 def ensure_generated_image_coding_feedback_skill(skills_root: Path):
@@ -4501,12 +5020,12 @@ Use this skill when the task depends on image understanding in a coding workflow
 - Generated image(s): current output from app, script, or model generation pipeline.
 - Code scope: file paths, rendering command, and runtime constraints.
 
-## Capability Gate
-1. Check active model/image pipeline capability first.
-2. If image input is supported, use direct vision reasoning for detailed comparison.
-3. If image input is unavailable, use fallback checks:
+## Image Analysis: Vision First
+1. Load all reference and generated images via `read_file` — the runtime injects them as native vision inputs automatically.
+2. Analyze images directly with model vision capabilities; do not use OCR or pixel heuristics when vision input is available.
+3. Fallback (only if the runtime explicitly reports vision input unavailable):
    - deterministic metadata checks (size/aspect/background),
-   - text checks (OCR if available),
+   - text checks via OCR tools (e.g., `tesseract`),
    - simple pixel-region checks from locally rendered output.
 4. Always report confidence level (`high|medium|low`) based on signal quality.
 
@@ -5904,6 +6423,7 @@ def ensure_generated_runtime_skills_manifest(skills_root: Path):
         "skills_Gen/knowledge_snapshot.json",
         "generated/upload-tabular-parser/SKILL.md",
         "generated/upload-office-parser/SKILL.md",
+        "generated/upload-image-parser/SKILL.md",
         "generated/image-coding-feedback-loop/SKILL.md",
         "generated/execution-degradation-recovery/SKILL.md",
         "generated/deep-research-orchestrator/SKILL.md",
@@ -9043,7 +9563,12 @@ TOOLS = [
     ),
     tool_def(
         "query_knowledge_library",
-        "Read current global knowledge-library status or query the TF-Graph_IDF RAG library for grounded document references.",
+        (
+            "Query the RAG knowledge library for grounded document references and background knowledge. "
+            "Call this BEFORE answering questions that require domain expertise, factual grounding, "
+            "or synthesis from imported documents. "
+            "Pass an empty query to check library status only."
+        ),
         {
             "query": {"type": "string"},
             "top_k": {"type": "integer"},
@@ -9374,6 +9899,8 @@ class SessionState:
         self.runtime_task_judgement = ""
         self.runtime_task_type = ""
         self.runtime_task_complexity = ""
+        self.runtime_complexity_floor = ""
+        self.runtime_task_level_floor = 0
         self.runtime_scale_preference = "balanced"
         self.runtime_direct_objective = ""
         self.runtime_reclassify_goal = ""
@@ -10454,6 +10981,12 @@ class SessionState:
                 self.runtime_reclassify_required = bool(
                     raw.get("runtime_reclassify_required", self.runtime_reclassify_required)
                 )
+                self.runtime_complexity_floor = str(
+                    raw.get("runtime_complexity_floor", self.runtime_complexity_floor) or ""
+                )
+                self.runtime_task_level_floor = int(
+                    raw.get("runtime_task_level_floor", self.runtime_task_level_floor) or 0
+                )
                 self.runtime_goal_reset_pending = bool(
                     raw.get("runtime_goal_reset_pending", self.runtime_goal_reset_pending)
                 )
@@ -10616,6 +11149,8 @@ class SessionState:
             "runtime_direct_objective": trim(str(self.runtime_direct_objective or ""), 800),
             "runtime_reclassify_goal": trim(str(self.runtime_reclassify_goal or ""), 4000),
             "runtime_reclassify_required": bool(self.runtime_reclassify_required),
+            "runtime_complexity_floor": str(self.runtime_complexity_floor or ""),
+            "runtime_task_level_floor": int(self.runtime_task_level_floor or 0),
             "runtime_goal_reset_pending": bool(self.runtime_goal_reset_pending),
             "runtime_plan_mode_needed": bool(self.runtime_plan_mode_needed),
             "runtime_plan_approved": bool(self.runtime_plan_approved),
@@ -10780,6 +11315,39 @@ class SessionState:
         self.runtime_code_reference_meta = {}
         return removed_hints
 
+    def _reset_blackboard_plan_state_locked(self) -> None:
+        """Clear plan/todo/skills state from a completed run so the next run starts fresh.
+
+        Called from submit_user_message when a new user request arrives after a
+        previous run finished (running=False, not awaiting plan choice).
+        Prevents the manager from seeing status=COMPLETED + all todos done and
+        immediately routing to 'finish' again on the very first round.
+        """
+        bb = self._ensure_blackboard()
+        bb["project_todos"] = []
+        bb["plan_steps"] = []
+        bb["plan_step_cursor"] = 0
+        bb["plan_step_total"] = 0
+        bb["status"] = ""
+        bb["approval"] = ""
+        bb["plan_findings"] = ""
+        bb["plan_proposal"] = ""
+        bb["plan_risks"] = ""
+        bb["loaded_skills"] = {}
+        bb["loaded_skills_goal_sig"] = ""
+        self.blackboard = bb
+        try:
+            self.todo.items = []
+        except Exception:
+            pass
+        # Clean up stale plan.md file from previous run
+        try:
+            _pf = self._plan_file_path()
+            if _pf.exists():
+                _pf.unlink()
+        except Exception:
+            pass
+
     def _event_payload_with_agent_role(self, kind: str, data: dict | None) -> dict:
         payload = dict(data or {})
         if self._sanitize_agent_bubble_role(payload.get("agent_role", "")):
@@ -11133,7 +11701,10 @@ class SessionState:
         skill_desc = str(skill_row.get("description", "-")).strip()
         inject_msg = (
             f"<loaded-skill name=\"{skill_key}\">\n"
-            f"A skill has been loaded. Follow its instructions precisely.\n"
+            f"A skill has been loaded. IMPORTANT: This skill's workflow, tools, and commands "
+            f"OVERRIDE the plan's implementation approach for any step where it applies. "
+            f"Read the full instructions below and follow them exactly — do NOT substitute a "
+            f"different tool, library, or language unless the skill explicitly allows it.\n"
             f"{trim(skill_text, 12000)}\n"
             f"</loaded-skill>"
         )
@@ -11594,14 +12165,28 @@ class SessionState:
             )
             return (
                 f"ACTIVE SKILLS: {names}. "
-                "Follow loaded skill instructions precisely. "
-                f"If you encounter a step requiring a workflow you don't know, call load_skill ({skill_count} available). "
+                "Follow the loaded skill instructions for the current step. "
+                f"When moving to a different step that needs a DIFFERENT skill, call load_skill to switch "
+                f"(or unload the current one first if it's no longer needed). "
+                f"{skill_count} skills available total. "
             )
         return (
             f"SKILL SYSTEM: {skill_count} skills available. "
-            "Use list_skills to discover, load_skill to activate. "
-            "If unsure how to produce professional output (docs, slides, analysis), check skills first. "
-        )
+            "Skills are loaded ON-DEMAND — decide when you need one based on the CURRENT step, not upfront. "
+            "For specialized output (reports, slides/PPT, deep research, code review, PDF analysis): "
+            "call list_skills to discover options, then load_skill to activate the right one. "
+            "Load a skill AT THE MOMENT you begin the step that requires it. "
+            "Unload it (via unload_skill) when moving to a different step that needs a different skill. "
+            "For simple tasks, direct questions, and multimodal analysis, do NOT load skills. "
+        )
+
+    def _skills_awareness_block(self, for_role: str = "developer") -> str:
+        """Canonical skills-awareness block shared by single, sync, and plan-mode.
+        Returns: loaded-skills hint  +  newline  +  'Skills:\\n<catalog>'
+        Keeps all three modes in sync — change here propagates everywhere.
+        """
+        hint = self._loaded_skills_prompt_hint(for_role=for_role)
+        return f"{hint}\nSkills:\n{self.skills.descriptions()}\n"
 
     def _refresh_runtime_code_reference(self, text: str):
         cb = getattr(self, "reference_prepare_callback", None)
@@ -11663,10 +12248,40 @@ class SessionState:
             header += " [" + ", ".join(tags) + "]"
         return (
             f"{header}:\n"
-            "This is the global TF-Graph_IDF RAG knowledge library for imported documents and research material. "
-            "It lives at the workspace root, not inside the current session files directory and not inside `.clouds_coder`. "
-            "Do not infer knowledge-library readiness by inspecting `session/files`, `uploads`, or `.clouds_coder/long_output`. "
-            "Use `query_knowledge_library` to check readiness or retrieve grounded references from the global library."
+            "Global TF-Graph_IDF RAG library for imported documents, PDFs, and research material. "
+            "IMPORTANT: When the task involves a topic you may have documents for — research, analysis, "
+            "fact-checking, synthesis — FIRST call query_knowledge_library(query='<topic>', top_k=8) "
+            "to retrieve grounded references BEFORE generating your answer. "
+            "Use route='hybrid' for best recall on broad topics; route='fast' for keyword lookups. "
+            "Do not infer readiness from session/files or uploads — query the library directly."
+        )
+
+    def _multimodal_capability_block(self) -> str:
+        """Return a brief system-prompt note about native multimodal capabilities.
+
+        Injected into system prompt so the model knows it can directly analyze
+        images/audio/video rather than falling back to text-only workarounds.
+        Returns empty string when the active model has no multimodal input caps.
+        """
+        try:
+            caps = self._capabilities_from_profile()
+        except Exception:
+            return ""
+        types = []
+        if caps.get("input_image"):
+            types.append("images")
+        if caps.get("input_audio"):
+            types.append("audio")
+        if caps.get("input_video"):
+            types.append("video")
+        if not types:
+            return ""
+        joined = "/".join(types)
+        return (
+            f"MULTIMODAL: This model supports native {joined} analysis. "
+            f"When {joined} are attached or loaded via read_file, analyze them DIRECTLY "
+            "using your built-in perception capabilities — do not describe them as "
+            "inaccessible or attempt text-only workarounds. "
         )
 
     def _code_library_prompt_block(self) -> str:
@@ -11747,8 +12362,14 @@ class SessionState:
         plan_ctx = self._plan_steps_context_for_manager()
         if plan_ctx:
             plan_steps_block = f"{plan_ctx}\n"
+        mm_block = self._multimodal_capability_block()
+        mm_hint = f"{mm_block}\n" if mm_block else ""
         return (
-            f"You are a coding agent. Workspace: {self.files_root}. "
+            f"You are a coding agent. Workspace: \"{self.files_root}\" ($SESSION_ROOT). "
+            f"Offline JS libraries root: $JS_LIB_ROOT. "
+            f"Structure: flat .js files at $JS_LIB_ROOT/<name>.min.js; "
+            f"pptxgenjs at $JS_LIB_ROOT/pptxgenjs/dist/pptxgen.cjs.js (CommonJS require) or pptxgen.bundle.js (browser). "
+            f"Do NOT look in node_modules — libs are installed directly under $JS_LIB_ROOT. "
             f"Task level={runtime_level}, mode={runtime_mode}, "
             f"budget={'unlimited' if budget <= 0 else budget}. "
             f"Context limit ~{self.context_token_upper_bound} tokens. "
@@ -11756,6 +12377,7 @@ class SessionState:
             "Use tools to inspect, edit, and execute. "
             "Call finish_current_task when done. "
             f"{skill_hint}"
+            f"{mm_hint}"
             f"{plan_steps_block}"
             f"{html_block}"
             f"{research_block}"
@@ -11911,7 +12533,7 @@ class SessionState:
                         o.pop("cons", None)
                         o.pop("risk", None)
         elif tier >= 3:
-            # Minimal: only phase, chosen, steps
+            # Minimal: only phase, chosen, steps — but preserve project_todos
             phase = plan.get("phase", "")
             chosen = plan.get("chosen", "")
             steps = plan.get("steps", [])
@@ -11927,7 +12549,10 @@ class SessionState:
                         o for o in options if isinstance(o, dict) and o.get("id") == chosen_id
                     ]
             if tier >= 3:
-                self.runtime_plan_proposal = {}
+                # Only clear proposal if plan is fully done
+                plan_phase = str(bb.get("plan", {}).get("phase", ""))
+                if plan_phase not in ("executing", "awaiting_choice"):
+                    self.runtime_plan_proposal = {}
 
     def _apply_auto_compact_if_needed(self, reason: str = "auto") -> bool:
         metrics = self._context_budget_metrics()
@@ -12329,16 +12954,13 @@ class SessionState:
         meta = {"filtered": False, "reason": "", "original_chars": len(raw)}
         if not clean:
             return raw, meta
-        if (
-            not tool_calls
-            and len(clean) >= int(RAW_TOOLCALL_TEXT_FILTER_THRESHOLD)
-            and self._looks_like_raw_toolcall_blob(clean)
-        ):
+        # Filter raw <tool_call> XML regardless of size — any size is invalid display content
+        if not tool_calls and self._looks_like_raw_toolcall_blob(clean):
             note = (
-                "[toolcall payload omitted: detected oversized inline <toolcall> text, "
-                "likely truncated. Please regenerate a compact structured tool call.]"
+                "[toolcall payload omitted: detected inline <toolcall> text. "
+                "Please regenerate a compact structured tool call.]"
             )
-            meta.update({"filtered": True, "reason": "oversized_raw_toolcall"})
+            meta.update({"filtered": True, "reason": "raw_toolcall"})
             return note, meta
         if len(raw) > int(ASSISTANT_TEXT_PERSIST_MAX_CHARS):
             clipped = trim(raw, int(ASSISTANT_TEXT_PERSIST_MAX_CHARS))
@@ -13540,6 +14162,11 @@ class SessionState:
         if low.startswith("/workspace/"):
             rel = raw[len("/workspace/") :].lstrip("/")
             return rel or "."
+        if low in {"/js_lib", "/js_lib/"}:
+            return ".__js_lib__"
+        if low.startswith("/js_lib/"):
+            rel = raw[len("/js_lib/") :].lstrip("/")
+            return f".__js_lib__/{rel}" if rel else ".__js_lib__"
         if low in {SKILLS_VIRTUAL_PREFIX, f"{SKILLS_VIRTUAL_PREFIX}/"}:
             return ".__skills__"
         if low.startswith(f"{SKILLS_VIRTUAL_PREFIX}/"):
@@ -13563,9 +14190,10 @@ class SessionState:
             return ""
         low = txt.lower()
         if (
-            low in {"/workspace", "/workspace/", SKILLS_VIRTUAL_PREFIX, f"{SKILLS_VIRTUAL_PREFIX}/"}
+            low in {"/workspace", "/workspace/", SKILLS_VIRTUAL_PREFIX, f"{SKILLS_VIRTUAL_PREFIX}/", "/js_lib", "/js_lib/"}
             or low.startswith("/workspace/")
             or low.startswith(f"{SKILLS_VIRTUAL_PREFIX}/")
+            or low.startswith("/js_lib/")
         ):
             return ""
         return (
@@ -13578,6 +14206,9 @@ class SessionState:
         if normalized == ".__skills__" or normalized.startswith(".__skills__/"):
             rel = normalized[len(".__skills__") :].lstrip("/")
             return safe_path(rel or ".", self.skills.skills_root)
+        if normalized == ".__js_lib__" or normalized.startswith(".__js_lib__/"):
+            rel = normalized[len(".__js_lib__") :].lstrip("/")
+            return safe_path(rel or ".", self.js_lib_root)
         return safe_path(normalized, self.files_root)
 
     def _session_rel(self, path: Path) -> str:
@@ -13585,6 +14216,13 @@ class SessionState:
         root = self.files_root.resolve()
         if target.is_relative_to(root):
             return target.relative_to(root).as_posix()
+        try:
+            js_lib_root = self.js_lib_root.resolve()
+            if target.is_relative_to(js_lib_root):
+                rel = target.relative_to(js_lib_root).as_posix()
+                return f"/js_lib/{rel}".replace("//", "/")
+        except Exception:
+            pass
         try:
             skills_root = self.skills.skills_root.resolve()
             if target.is_relative_to(skills_root):
@@ -13962,8 +14600,20 @@ class SessionState:
         }
 
     def _safe_upload_name(self, filename: str) -> str:
+        # Use Path().name to strip any directory component first.
         raw = Path(str(filename or "upload.bin")).name
-        safe = re.sub(r"[^A-Za-z0-9._-]+", "_", raw).strip("._")
+        # Only remove characters that are genuinely illegal or dangerous on
+        # filesystems (path separators, null byte, control chars, Windows
+        # reserved chars). Unicode letters/CJK/etc. are left untouched so
+        # filenames like "我的数据.xlsx" remain readable.
+        safe = re.sub(r'[/\\\x00-\x1f\x7f:*?"<>|]', "_", raw)
+        safe = safe.strip(". ")  # avoid hidden files (leading dot) and trailing issues
+        # Enforce a byte-length ceiling safe across all filesystems (255 bytes max).
+        # Trim the stem if needed while preserving the extension.
+        if len(safe.encode("utf-8", errors="replace")) > 240:
+            ext = Path(safe).suffix  # e.g. ".xlsx"
+            stem = safe[: max(1, 200 - len(ext))]
+            safe = stem + ext
         return safe or f"upload_{int(now_ts())}.bin"
 
     def _decode_text_bytes(self, data: bytes) -> str:
@@ -15964,15 +16614,22 @@ class SessionState:
             skills_root = str(self.skills.skills_root.resolve())
         except Exception:
             skills_root = str(self.skills.skills_root)
+        try:
+            js_lib_root = str(self.js_lib_root.resolve())
+        except Exception:
+            js_lib_root = str(self.js_lib_root)
         mappings = [
             ("/workspace", workspace_root),
             (SKILLS_VIRTUAL_PREFIX, skills_root),
+            ("/js_lib", js_lib_root),
         ]
         # Auto-quote raw absolute paths that contain spaces (prevents word-splitting)
         if " " in workspace_root and workspace_root not in ("/workspace",):
             mappings.append((workspace_root, workspace_root))
         if " " in skills_root and skills_root != SKILLS_VIRTUAL_PREFIX:
             mappings.append((skills_root, skills_root))
+        if " " in js_lib_root and js_lib_root != "/js_lib":
+            mappings.append((js_lib_root, js_lib_root))
         out: list[str] = []
         mode = "plain"
         i = 0
@@ -16313,6 +16970,7 @@ class SessionState:
             proc_env["SESSION_FILES_ROOT"] = str(self.files_root)
             proc_env["SKILLS_ROOT"] = str(self.skills.skills_root)
             proc_env["CLOUDS_CODER_ROOT"] = str(self.root)
+            proc_env["JS_LIB_ROOT"] = str(self.js_lib_root)
             popen_kwargs = {
                 "shell": True,
                 "cwd": cwd,
@@ -16430,10 +17088,31 @@ class SessionState:
     def _run_bash(self, command: str) -> str:
         return self._run_shell_meta(command, self.files_root, 120)["output"]
 
+    def _fuzzy_resolve_path(self, fp: Path) -> Path:
+        """If fp doesn't exist, try stripping spaces from the filename to find a close match.
+        Handles the common model error of hallucinating spaces in Chinese/mixed filenames.
+        Returns the resolved Path if found, otherwise the original fp unchanged."""
+        if fp.exists():
+            return fp
+        stripped = fp.name.replace(" ", "")
+        if stripped != fp.name:
+            candidate = fp.parent / stripped
+            if candidate.exists():
+                return candidate
+        try:
+            query = fp.name.replace(" ", "").lower()
+            for sibling in fp.parent.iterdir():
+                if sibling.name.replace(" ", "").lower() == query:
+                    return sibling
+        except Exception:
+            pass
+        return fp
+
     def _run_read(self, path: str, limit: int | None = None, offset: int | None = None) -> str:
         try:
             rel = self._normalize_tool_path_text(path)
-            fp = self._session_path(rel)
+            fp = self._fuzzy_resolve_path(self._session_path(rel))
+            rel = str(fp.relative_to(self.files_root)) if fp.is_relative_to(self.files_root) else rel
             # Multimodal: detect image/audio/video files and handle natively
             ext = fp.suffix.lower() if fp.suffix else ""
             if ext in IMAGE_EXTS:
@@ -16680,7 +17359,8 @@ class SessionState:
     def _run_write(self, path: str, content: str) -> str:
         try:
             rel = self._normalize_tool_path_text(path)
-            fp = self._session_path(rel)
+            fp = self._fuzzy_resolve_path(self._session_path(rel))
+            rel = str(fp.relative_to(self.files_root)) if fp.is_relative_to(self.files_root) else rel
             fp.parent.mkdir(parents=True, exist_ok=True)
             fp.write_text(content, encoding="utf-8")
             return f"Wrote {len(content)} bytes to {rel}"
@@ -16690,7 +17370,8 @@ class SessionState:
     def _run_edit(self, path: str, old_text: str, new_text: str) -> str:
         try:
             rel = self._normalize_tool_path_text(path)
-            fp = self._session_path(rel)
+            fp = self._fuzzy_resolve_path(self._session_path(rel))
+            rel = str(fp.relative_to(self.files_root)) if fp.is_relative_to(self.files_root) else rel
             content = fp.read_text(encoding="utf-8")
             if old_text not in content:
                 diag = self._edit_mismatch_diagnostic(content, old_text)
@@ -18445,7 +19126,7 @@ class SessionState:
             board["project_todos"] = []
         else:
             clean_todos = []
-            for pt in bb_src_todos[:20]:
+            for pt in bb_src_todos[:40]:
                 if not isinstance(pt, dict):
                     continue
                 clean_todos.append({
@@ -18514,6 +19195,15 @@ class SessionState:
         goal_preview = trim(str(src.get("loaded_skills_goal_preview", "") or ""), 240)
         if goal_preview:
             board["loaded_skills_goal_preview"] = goal_preview
+        # Preserve step_files registry across normalization
+        raw_step_files = src.get("step_files")
+        if isinstance(raw_step_files, dict):
+            clean_sf: dict[str, list] = {}
+            for sf_key, sf_entries in raw_step_files.items():
+                if isinstance(sf_entries, list):
+                    clean_sf[str(sf_key)] = sf_entries[-30:]
+            if clean_sf:
+                board["step_files"] = clean_sf
         return board
 
     def _normalize_failure_ledger(self, raw: dict) -> dict:
@@ -18941,9 +19631,17 @@ class SessionState:
             self.blackboard["loaded_skills"] = preserved_skills
             self.blackboard["loaded_skills_goal_sig"] = preserved_skills_sig
             self.blackboard["loaded_skills_goal_preview"] = trim(str(goal or ""), 240)
-        # Restore plan state if plan is in executing phase
-        if isinstance(preserved_plan, dict) and preserved_plan.get("phase") == "executing":
-            self.blackboard["plan"] = preserved_plan
+        # Restore plan state if plan is active (any phase) or todos have pending work
+        has_active_plan = (
+            isinstance(preserved_plan, dict)
+            and preserved_plan.get("phase") in ("executing", "research", "synthesis", "awaiting_choice")
+        )
+        has_active_todos = isinstance(preserved_todos, list) and any(
+            t.get("status") != "completed" for t in preserved_todos if isinstance(t, dict)
+        )
+        if has_active_plan or has_active_todos:
+            if isinstance(preserved_plan, dict):
+                self.blackboard["plan"] = preserved_plan
             if isinstance(preserved_todos, list) and preserved_todos:
                 self.blackboard["project_todos"] = preserved_todos
             if preserved_cursor is not None:
@@ -19440,35 +20138,36 @@ class SessionState:
         if not current:
             return False
         text = (str(instruction or "") + " " + str(reason or "")).lower()
-        # Patterns that indicate step completion
+        # Patterns that indicate step completion — only BACKWARD-looking signals
+        # (agent/manager explicitly says a step is done, NOT forward-looking dispatch instructions)
         step_done_patterns = (
             "审查通过", "通过审查", "已通过", "已完成", "完成了",
-            "进入 step", "进入step", "enter step", "move to step",
             "step completed", "step done", "step passed",
-            "现在进入", "开始 step", "开始step",
             "阶段完成", "阶段通过", "phase complete",
-            # extended: manager says "now do step X.Y" implying prior step is done
-            "现在执行步骤", "执行步骤 1.2", "执行步骤 1.3", "执行步骤 2",
-            "进入下一步", "next step", "proceed to step",
-            "步骤 1.1 已完成", "步骤 1.2 已完成",
+            "步骤 1.1 已完成", "步骤 1.2 已完成", "步骤 1.3 已完成",
+            "步骤 1.4 已完成", "步骤 1.5 已完成",
         )
-        # Also detect "Step N 通过" or "进入 Step N+1" patterns
+        # NOTE: intentionally excluded forward-looking dispatch patterns:
+        #   "现在执行步骤", "执行步骤 1.2", "执行步骤 1.3", "进入下一步", "next step",
+        #   "proceed to step", "进入 step", "开始 step" — these are manager dispatch
+        #   instructions, NOT evidence that the current step was completed.
         import re
         current_idx = int(current.get("plan_step_index", 0) or 0)
-        # "Step 2 已通过" / "Step 2 完成" / "进入 Step 3"
+        # Only advance when an agent explicitly says "进入 Step N" where N > current+1
+        # (skipping ahead), NOT when manager dispatches the very next step.
         next_step_pattern = re.search(
             r'(?:进入|enter|move\s+to|start|proceed\s+to)\s*(?:step\s*)?(\d+)',
             text, re.IGNORECASE
         )
         if next_step_pattern:
             mentioned_step = int(next_step_pattern.group(1))
-            if mentioned_step > current_idx + 1:
+            if mentioned_step > current_idx + 2:  # must skip at least 2 ahead to be meaningful
                 return True
-        # Pattern: "继续步骤 1.2" / "完成步骤 1.1，开始 1.2"
-        step_ref = re.search(r'步骤\s*1\.(\d+)', text)
+        # "完成步骤 1.1，开始 1.2" — only if explicitly marking current step done
+        step_ref = re.search(r'(?:完成|finished|done)\s*步骤\s*1\.(\d+)', text)
         if step_ref:
             ref_sub = int(step_ref.group(1))
-            if ref_sub > (current_idx + 1):
+            if ref_sub == current_idx + 1:  # explicitly says current step (1-based) is done
                 return True
         return any(pat in text for pat in step_done_patterns)
 
@@ -19505,14 +20204,19 @@ class SessionState:
             })
         self.blackboard = bb
         self._blackboard_touch()
-        # 步骤推进时清除 in_progress/pending 的 worker 子任务，防止跨步骤堆积
-        # 保留 completed 的 worker 项，让 UI 保持已完成记录可见
+        # Persist step status change to plan.md
+        try:
+            self._update_plan_file_step_status()
+        except Exception:
+            pass  # Plan file update is best-effort
+        # 步骤推进时按 parent_step_id 清除对应步骤的 worker 子任务
+        # 保留 completed 的 worker 项和不属于当前步骤的 worker 项
+        completed_step_id = str(current.get("id", "") or "")
         try:
             _snap = self.todo.snapshot()
-            _worker_owners = {"developer", "explorer", "reviewer"}
             _clean = [
                 r for r in _snap
-                if str(r.get("owner", "") or "").lower() not in _worker_owners
+                if str(r.get("parent_step_id", "") or "") != completed_step_id
                 or str(r.get("status", "") or "").lower() == "completed"
             ]
             if len(_clean) < len(_snap):
@@ -19524,11 +20228,87 @@ class SessionState:
         self._sync_todos_from_blackboard(reason=f"plan-step-advanced:{cursor + 1}", board=bb)
         if next_step:
             try:
-                self._refresh_loaded_skills_for_execution_focus(trigger="plan-step-advanced")
+                pass  # Skills are loaded on-demand by the model via load_skill
             except Exception:
                 pass
         return True
 
+    def _post_execution_plan_step_check(self, route: dict, worker_step: dict):
+        """After worker execution, check if current plan step should advance based on evidence."""
+        bb = self._ensure_blackboard()
+        current = next(
+            (t for t in bb.get("project_todos", [])
+             if t.get("category") == "plan_step" and t.get("status") == "in_progress"),
+            None,
+        )
+        if not current:
+            return
+        # 1. Manager explicitly requested advancement
+        manager_requested = bool(route.get("advance_plan_step_requested", False))
+        # 2. Worker produced concrete tool outputs
+        worker_produced_output = self._worker_step_has_evidence(worker_step)
+        # 3. All subtasks for this step are completed
+        subtasks_all_done = self._step_subtasks_all_completed(current)
+        # Advance only when evidence confirms step completion:
+        # - Manager requested AND worker produced output, OR
+        # - All subtasks completed AND worker produced output
+        has_strong_evidence = worker_produced_output and (
+            manager_requested or subtasks_all_done
+        )
+        if has_strong_evidence:
+            evidence = self._collect_step_evidence(current, worker_step)
+            self._advance_plan_step(
+                evidence=evidence,
+                actor=str(route.get("target", "developer") or "developer"),
+            )
+
+    def _worker_step_has_evidence(self, step: dict) -> bool:
+        """Check if worker step produced concrete tool outputs."""
+        results = step.get("tool_results", []) or []
+        return any(
+            r.get("ok", False) and str(r.get("name", "")) in (
+                "write_file", "edit_file", "bash", "read_file",
+                "write_to_blackboard", "finish_current_task",
+            )
+            for r in results
+            if isinstance(r, dict)
+        )
+
+    def _step_subtasks_all_completed(self, plan_step: dict) -> bool:
+        """Check if all worker subtasks linked to this plan step are completed."""
+        step_id = str(plan_step.get("id", "") or "")
+        if not step_id:
+            return False
+        snap = self.todo.snapshot()
+        worker_owners = {"developer", "explorer", "reviewer"}
+        worker_items = [
+            r for r in snap
+            if str(r.get("owner", "") or "").lower() in worker_owners
+            and str(r.get("parent_step_id", "") or "") == step_id
+        ]
+        if not worker_items:
+            return False
+        return all(str(r.get("status", "")).lower() == "completed" for r in worker_items)
+
+    def _collect_step_evidence(self, plan_step: dict, worker_step: dict) -> str:
+        """Collect evidence summary from worker step for plan step completion."""
+        parts = []
+        results = worker_step.get("tool_results", []) or []
+        for r in results:
+            if not isinstance(r, dict) or not r.get("ok", False):
+                continue
+            name = str(r.get("name", ""))
+            if name in ("write_file", "edit_file"):
+                path = str(r.get("args", {}).get("path", "") or "")
+                parts.append(f"{name}: {path}")
+            elif name == "bash":
+                cmd = trim(str(r.get("args", {}).get("command", "") or ""), 80)
+                parts.append(f"bash: {cmd}")
+            elif name == "read_file":
+                path = str(r.get("args", {}).get("path", "") or "")
+                parts.append(f"read: {path}")
+        return trim("; ".join(parts) or "post-execution evidence", 200)
+
     def _single_agent_plan_step_check(self, tool_results: list[dict]):
         """In single-agent mode, check if current plan step should be advanced based on tool results."""
         bb = self._ensure_blackboard()
@@ -19602,6 +20382,7 @@ class SessionState:
                     _step_label = f"Step {_step_idx}" + (f"/{_total}" if _total else "")
                     _hint = (
                         f"[plan-step-advance] Previous step completed. Now at {_step_label}: {_step_text}\n"
+                        f"Read updated plan: read_file {PLAN_FILE_RELATIVE_PATH}\n"
                         "Call TodoWrite to set your task breakdown for this step "
                         "(3-5 subtask items, one marked in_progress) before proceeding."
                     )
@@ -19659,8 +20440,13 @@ class SessionState:
             if is_system_key or owner == "manager":
                 continue
             non_system_rows.append(dict(row))
-        remaining_cap = max(0, 20 - len(system_rows) - len(worker_rows))
-        merged = list(system_rows) + worker_rows + non_system_rows[:remaining_cap]
+        # Smart trim: keep all active (in_progress/pending) system rows,
+        # but only recent 3 completed system rows to save capacity for worker subtasks
+        active_system = [r for r in system_rows if r.get("status") != "completed"]
+        completed_system = [r for r in system_rows if r.get("status") == "completed"]
+        trimmed_system = active_system + completed_system[-3:]
+        remaining_cap = max(0, 40 - len(trimmed_system) - len(worker_rows))
+        merged = list(trimmed_system) + worker_rows + non_system_rows[:remaining_cap]
         try:
             todo_out = self.todo.update(merged)
         except Exception:
@@ -20606,7 +21392,7 @@ class SessionState:
             f"budget={int(self.runtime_round_budget or 0)}.\n\n"
             f"{dims_ctx}"
             f"{skills_ctx}"
-            f"Workspace root: {self.files_root}\n"
+            f"Workspace root: \"{self.files_root}\" ($SESSION_ROOT)\n"
             "Infer scale_preference by semantics (fast/balanced/thorough). "
             "When user preference is clear, prioritize it over your default plan. "
             "Remember: budget controls internal thought depth/round compactness, not early stop messaging. "
@@ -20815,7 +21601,8 @@ class SessionState:
         todos = bb.get("project_todos", [])
         if not todos or not any(t.get("category") == "plan_step" for t in todos):
             return ""
-        lines = ["APPROVED PLAN STEPS:"]
+        lines = [f"PLAN FILE: {PLAN_FILE_RELATIVE_PATH} (read_file for full plan with live status)",
+                 "APPROVED PLAN STEPS:"]
         for t in todos:
             if t.get("category") != "plan_step":
                 continue
@@ -20827,10 +21614,14 @@ class SessionState:
             lines.append(f"  {mark} Step {idx}: {trim(str(t.get('content', '') or ''), 160)}{phase_tag}")
         lines.append("Execute steps IN ORDER. Do NOT skip ahead. Mark current step done before advancing. ")
         lines.append(
-            "STEP COMPLETION RULE: Set advance_plan_step=true when the worker has provided concrete evidence "
-            "that the current step is done — e.g., research_notes populated for a read/analyze step, "
-            "code_artifacts created for an implement step, or all worker TodoWrite subtasks marked completed. "
-            "Do NOT keep re-delegating the same step once this evidence exists. "
+            "STEP COMPLETION RULE: Set advance_plan_step=true ONLY when:\n"
+            "  1. The worker has ALREADY executed tools and produced verifiable output "
+            "(NOT when dispatching the work for the first time), AND\n"
+            "  2. At least ONE of: research_notes populated, code_artifacts created, "
+            "bash execution succeeded, or all worker TodoWrite subtasks (with parent_step_id) completed.\n"
+            "  NEVER set advance_plan_step=true in the SAME delegation that assigns the work. "
+            "The step must have been executed FIRST.\n"
+            "COMPLEXITY LOCK: Do NOT change complexity or task_level below the plan-approved levels. "
         )
         lines.append("MANDATORY: Your delegation instruction MUST reference the current plan step. "
                      "Do NOT reinterpret or replace plan steps with your own objectives. ")
@@ -20859,12 +21650,15 @@ class SessionState:
     def _plan_step_phase_hint(self, step_content: str) -> str:
         """Infer the task phase from a plan step's content."""
         c = str(step_content or "").lower()
+        # implement keywords take priority — if step produces output, it's implement not design/research
+        if any(kw in c for kw in ("实现", "编写", "创建", "开发", "绘制", "生成", "写入",
+                                   "implement", "write", "create", "build", "develop", "code",
+                                   "generate", "draw", "scaffold", "mkdir", ".f90", ".py", ".cpp", ".md")):
+            return "implement"
         if any(kw in c for kw in ("研究", "分析", "调研", "探索", "research", "analyze", "investigate", "explore", "inspect")):
             return "research"
         if any(kw in c for kw in ("设计", "架构", "规划", "design", "architect", "plan", "interface", "接口")):
             return "design"
-        if any(kw in c for kw in ("实现", "编写", "创建", "开发", "implement", "write", "create", "build", "develop", "code")):
-            return "implement"
         if any(kw in c for kw in ("测试", "验证", "检查", "test", "verify", "check", "validate", "compile")):
             return "test"
         if any(kw in c for kw in ("审查", "评审", "review", "audit", "inspect code")):
@@ -20927,11 +21721,24 @@ class SessionState:
                     completed_w = [r for r in worker_todos if str(r.get("status", "")).lower() == "completed"]
                     pending_w = [r for r in worker_todos if str(r.get("status", "")).lower() not in ("completed",)]
                     if not pending_w and completed_w:
-                        worker_hint = (
-                            f"Worker subtasks: all {len(completed_w)} completed "
-                            f"({', '.join(trim(str(r.get('content','') or ''), 40) for r in completed_w[:3])}). "
-                            "→ Worker has finished. Set advance_plan_step=true NOW. "
-                        )
+                        # Verify actual work evidence before suggesting advance
+                        bb_now = self._ensure_blackboard()
+                        has_artifacts = bool(bb_now.get("code_artifacts"))
+                        has_research = bool(bb_now.get("research_notes"))
+                        has_shell_output = bool(bb_now.get("execution_logs"))
+                        has_evidence = has_artifacts or has_research or has_shell_output
+                        if has_evidence:
+                            worker_hint = (
+                                f"Worker subtasks: all {len(completed_w)} completed "
+                                f"({', '.join(trim(str(r.get('content','') or ''), 40) for r in completed_w[:3])}). "
+                                "Blackboard has concrete outputs. \u2192 Set advance_plan_step=true NOW. "
+                            )
+                        else:
+                            worker_hint = (
+                                f"Worker subtasks: all {len(completed_w)} marked completed "
+                                "but blackboard has NO concrete outputs (no code_artifacts, research_notes, or execution_logs). "
+                                "\u2192 Do NOT advance. Re-delegate to verify actual work was done. "
+                            )
                     elif completed_w or pending_w:
                         worker_hint = (
                             f"Worker subtasks: {len(completed_w)} done, {len(pending_w)} pending. "
@@ -22185,7 +22992,7 @@ class SessionState:
                 prompt = (
                     "Read the blackboard and delegate one next short timeslice. "
                     "Return only one route_to_next_agent call.\n\n"
-                    f"{self._blackboard_read_state_markdown(max_items=6)}"
+                    f"{self._blackboard_read_state_markdown(max_items=10)}"
                 )
                 self._append_manager_context({"role": "user", "content": prompt, "ts": now_ts()})
                 self._microcompact_agent_messages(self.manager_context)
@@ -22384,22 +23191,12 @@ class SessionState:
             "round_budget": int(round_budget),
             "remaining_rounds": int(remaining_rounds),
         }
-        # advance_plan_step: 当前 plan step 完成，推进到下一步
-        should_advance = _to_bool_like(route.get("advance_plan_step", False), default=False)
-        # Auto-detect step advancement from instruction semantics
-        if not should_advance:
-            should_advance = self._instruction_implies_step_advance(
-                str(route.get("instruction", "") or ""),
-                str(route.get("reason", "") or ""),
-            )
-        if should_advance:
-            self._advance_plan_step(
-                evidence=trim(str(route.get("instruction", "") or ""), 200),
-                actor=str(route.get("target", "developer") or "developer"),
-            )
-            # CRITICAL: re-anchor board to the updated blackboard so the
-            # self.blackboard = board at line ~22388 does NOT overwrite the advance.
-            board = self.blackboard
+        # advance_plan_step: REMOVED pre-execution advancement.
+        # Step advancement now happens AFTER worker execution via _post_execution_plan_step_check.
+        # Store the manager's advance request flag for post-execution validation.
+        route_row["advance_plan_step_requested"] = _to_bool_like(
+            route.get("advance_plan_step", False), default=False
+        )
         self.manager_routes.append(route_row)
         self.manager_routes = self.manager_routes[-240:]
         # Failure ledger: persist route and record delegation
@@ -22416,7 +23213,11 @@ class SessionState:
         self.blackboard = board
         self._ledger_record_delegation(target, instruction)
         profile = self._ensure_blackboard_task_profile(board)
-        profile["task_level"] = int(task_level)
+        # Complexity / task_level floor protection: prevent manager downgrade during plan execution
+        effective_level = int(task_level)
+        if int(self.runtime_task_level_floor or 0) > 0:
+            effective_level = max(effective_level, int(self.runtime_task_level_floor))
+        profile["task_level"] = effective_level
         profile["execution_mode"] = execution_mode
         profile["participants"] = list(participants)
         profile["assigned_expert"] = assigned_expert
@@ -22426,6 +23227,9 @@ class SessionState:
         if task_type in TASK_PROFILE_TYPES:
             profile["task_type"] = task_type
         if complexity in TASK_COMPLEXITY_LEVELS:
+            # Floor protection: if plan mode set a floor, do not allow downgrade
+            if self.runtime_complexity_floor == "complex" and complexity == "simple":
+                complexity = "complex"
             profile["complexity"] = complexity
         profile["scale_preference"] = scale_preference if scale_preference in TASK_SCALE_PREFERENCES else "balanced"
         if objective:
@@ -22633,7 +23437,7 @@ class SessionState:
                 "Do NOT repeat previous failed fixes.\n"
                 "</compile-error-context>\n"
             )
-        board_md = self._blackboard_read_state_markdown(max_items=5)
+        board_md = self._blackboard_read_state_markdown(max_items=10)
         # Include loaded skills hint in delegation
         loaded_skills_note = self._loaded_skills_prompt_hint(for_role=role_key)
         # Include current plan step in delegation so agents stay on track
@@ -22653,11 +23457,46 @@ class SessionState:
         # developer 被调用时有活跃 plan step，要求在开始前调用 TodoWrite 刷新子任务
         todo_update_note = ""
         if role_key == "developer" and current_plan_step_note:
+            # Extract step_id from the matched plan step for parent_step_id linkage
+            _active_step_id = ""
+            if isinstance(plan_todos, list):
+                for _pt in plan_todos:
+                    if isinstance(_pt, dict) and _pt.get("category") == "plan_step" and _pt.get("status") == "in_progress":
+                        _active_step_id = str(_pt.get("id", "") or "")
+                        break
             todo_update_note = (
-                "TODO UPDATE: Call TodoWrite at the start of your work to set your task breakdown "
-                "for this step (3-5 subtask items, one marked in_progress). "
-                "Mark each subtask completed as you finish it.\n"
-            )
+                f"TODO UPDATE: At the START of your work, call TodoWrite to set subtasks for this step.\n"
+                f"Each subtask MUST include parent_step_id='{_active_step_id}' to link it to this plan step.\n"
+                f"Format: 3-5 items, one marked in_progress, others pending.\n"
+                f"Mark each subtask completed as you finish it. When ALL subtasks are done, the step auto-advances.\n"
+            )
+        # Build step_files context note for cross-agent file visibility
+        step_files_note = ""
+        if current_plan_step_note:
+            try:
+                _sf_bb = self._ensure_blackboard()
+                _sf_data = _sf_bb.get("step_files", {})
+                _sf_step_id = ""
+                if isinstance(plan_todos, list):
+                    for _sfpt in plan_todos:
+                        if isinstance(_sfpt, dict) and _sfpt.get("category") == "plan_step" and _sfpt.get("status") == "in_progress":
+                            _sf_step_id = str(_sfpt.get("id", "") or "")
+                            break
+                if _sf_step_id and isinstance(_sf_data, dict):
+                    _sf_entries = _sf_data.get(_sf_step_id, [])
+                    if _sf_entries:
+                        _sf_paths = list(dict.fromkeys(
+                            str(e.get("path", "") or "")
+                            for e in _sf_entries[-20:]
+                            if isinstance(e, dict) and e.get("path")
+                        ))
+                        if _sf_paths:
+                            step_files_note = (
+                                "FILES ACCESSED IN THIS STEP:\n"
+                                + "\n".join(f"- {p}" for p in _sf_paths[:15]) + "\n"
+                            )
+            except Exception:
+                pass
         payload = (
             "<manager-delegate>\n"
             f"target={role_key}\n"
@@ -22672,6 +23511,7 @@ class SessionState:
             f"{loaded_skills_note}"
             f"{current_plan_step_note}"
             f"{todo_update_note}"
+            f"{step_files_note}"
             f"{error_section}"
             "</manager-delegate>\n"
             "<blackboard-state>\n"
@@ -22779,6 +23619,32 @@ class SessionState:
                 role_key,
                 f"tool_error {name}: {output}",
             )
+        # Track file operations in step_files registry for cross-agent context
+        if name in ("read_file", "write_file", "edit_file"):
+            file_path = trim(str(args.get("path", "") or "").strip(), 240)
+            if file_path:
+                try:
+                    bb = self._ensure_blackboard()
+                    current_step = next(
+                        (t for t in bb.get("project_todos", [])
+                         if t.get("category") == "plan_step" and t.get("status") == "in_progress"),
+                        None,
+                    )
+                    if current_step:
+                        step_id = str(current_step.get("id", "") or "")
+                        if step_id:
+                            sf = bb.setdefault("step_files", {})
+                            entries = sf.setdefault(step_id, [])
+                            entries.append({
+                                "path": file_path,
+                                "role": role_key,
+                                "op": name,
+                                "ts": float(now_ts()),
+                            })
+                            if len(entries) > 30:
+                                sf[step_id] = entries[-30:]
+                except Exception:
+                    pass
 
     def _blackboard_update_from_worker_step(self, role: str, step: dict):
         role_key = self._sanitize_agent_role(role)
@@ -23391,19 +24257,32 @@ class SessionState:
 
     def _agent_role_system_prompt(self, role: str) -> str:
         role_key = self._sanitize_agent_role(role) or "developer"
-        skills_note = self._loaded_skills_prompt_hint(for_role=role_key)
+        skills_block = self._skills_awareness_block(for_role=role_key)
         code_note = self._runtime_code_reference_prompt_block(max_chars=2600)
         base = (
             f"You are {self._agent_display_name(role_key)} in a multi-agent coding system. "
-            f"Workspace: {self.files_root}. Use relative paths. "
+            f"Workspace: \"{self.files_root}\" ($SESSION_ROOT). Use relative paths or $SESSION_ROOT in bash. "
+            f"Offline JS libraries root: $JS_LIB_ROOT. "
+            f"Structure: flat .js files at $JS_LIB_ROOT/<name>.min.js; "
+            f"pptxgenjs at $JS_LIB_ROOT/pptxgenjs/dist/pptxgen.cjs.js (CommonJS) or pptxgen.bundle.js (browser). "
+            f"Do NOT look in node_modules — libs are installed directly under $JS_LIB_ROOT. "
             "Use blackboard for shared state, ask_colleague for inter-agent communication. "
             "Keep outputs concise and action-oriented. "
-            f"{skills_note}{code_note + ' ' if code_note else ''}"
+            f"{code_note + ' ' if code_note else ''}"
             f"{_detect_os_shell_instruction()} "
             f"{model_language_instruction(self.ui_language)} "
         )
+        mm_note = self._multimodal_capability_block()
+        if mm_note:
+            base = base + mm_note
+        base = base + skills_block
         if role_key == "explorer":
-            return base + "Role: analyze goals, inspect codebase, produce research notes. Prefer read/search. "
+            return base + (
+                "Role: analyze goals, inspect codebase, produce research notes. "
+                "For factual or background questions on any topic, FIRST call "
+                "query_knowledge_library(query='<topic>', top_k=8, route='hybrid') to retrieve relevant documents. "
+                "Prefer read/search tools. "
+            )
         if role_key == "reviewer":
             if bool(self.reviewer_debug_mode):
                 debug_ctx = trim(str(self.reviewer_debug_context or ""), 500)
@@ -23436,6 +24315,11 @@ class SessionState:
             )
         return base + (
             "Role: implement code changes, execute tools, record progress to blackboard. "
+            "SKILL PRIORITY (critical): When ACTIVE SKILLS are listed above, find the "
+            "<loaded-skill> messages in your context and READ them before starting any step. "
+            "The skill's workflow, tools, and file structure OVERRIDE the plan's implementation "
+            "approach — if the plan says 'use python-pptx' but the skill says 'use PptxGenJS', "
+            "use PptxGenJS. The skill defines HOW to implement; the plan defines WHAT to do. "
             "TODO TRACKING (mandatory): "
             "After completing each logical step, call TodoWrite to update progress — "
             "mark completed items as 'completed' and set the next item to 'in_progress'. "
@@ -24389,7 +25273,8 @@ class SessionState:
                     isinstance(it, dict) and str(it.get("status", it.get("state", ""))).lower() in {"completed", "done", "finished", "finish"}
                     for it in new_items
                 ):
-                    self._refresh_loaded_skills_for_execution_focus(trigger="step-completed")
+                    self._refresh_loaded_skills_for_execution_focus(trigger="step-completed")  # noqa: removed
+                    pass  # Skills are loaded on-demand by the model
             except Exception:
                 pass
             return result
@@ -24397,7 +25282,7 @@ class SessionState:
             result = self._todo_write_rescue(args)
             # Also recheck skills on rescue write (likely a recovery situation)
             try:
-                self._refresh_loaded_skills_for_execution_focus(trigger="todo-rescue")
+                pass  # Skills are loaded on-demand by the model via load_skill
             except Exception:
                 pass
             return result
@@ -24848,8 +25733,6 @@ class SessionState:
                     "</live-user-adjustment>"
                 )
                 self.messages.append({"role": "user", "content": payload, "ts": now_ts()})
-                # Merge user feedback with plan direction
-                self._merge_user_feedback_with_plan(content)
                 self.runtime_reclassify_goal = trim(content, 4000)
                 # Only trigger reclassification in auto mode (no user override)
                 if int(getattr(self, 'user_task_level_override', 0) or 0) > 0:
@@ -24863,6 +25746,7 @@ class SessionState:
                         "weight": weight,
                         "priority": priority,
                         "applied": applied,
+                        "content": content,
                     }
                 )
                 row["applied_count"] = applied
@@ -24875,6 +25759,8 @@ class SessionState:
                 self.updated_at = now_ts()
                 self._persist()
         for item in injected:
+            # Merge user feedback with plan direction (outside lock — may do LLM call)
+            self._merge_user_feedback_with_plan(item["content"])
             self._emit(
                 "status",
                 {
@@ -24887,6 +25773,49 @@ class SessionState:
             )
         return len(injected)
 
+    def _user_feedback_conflict_score(self, user_text: str, step_desc: str = "") -> float:
+        """Score 0.0–1.0 via LLM semantic analysis: how strongly user feedback conflicts with current plan.
+        Falls back to 0.5 on error."""
+        if not str(user_text or "").strip():
+            return 0.0
+        try:
+            ctx = [
+                {"role": "system", "content": (
+                    "You are a semantic conflict analyzer. "
+                    "Given a user's mid-execution feedback and the current task step, "
+                    "output ONLY a JSON object: {\"score\": <float 0.0-1.0>, \"reason\": \"<brief>\"}. "
+                    "score=0.0 means fully aligned (minor tweak/clarification). "
+                    "score=1.0 means direct contradiction/override (user wants opposite direction). "
+                    "No other text."
+                ), "ts": now_ts()},
+                {"role": "user", "content": (
+                    f"Current step: {trim(step_desc, 300) or 'unknown'}\n"
+                    f"User feedback: {trim(user_text, 500)}\n"
+                    "Output JSON only."
+                ), "ts": now_ts()},
+            ]
+            resp = self._chat_with_same_model_retry(
+                ctx,
+                tools=None,
+                system=None,
+                max_tokens=80,
+                think=False,
+                stream_thinking=False,
+                context_label="feedback-conflict-score",
+                retries=1,
+            )
+            text = str(resp.get("content", "") or "").strip()
+            # Extract JSON from response
+            import re as _re
+            m = _re.search(r'\{[^}]+\}', text)
+            if m:
+                parsed = parse_json_object(m.group(0), {})
+                score = float(parsed.get("score", 0.5) or 0.5)
+                return max(0.0, min(1.0, score))
+        except Exception:
+            pass
+        return 0.5
+
     def _merge_user_feedback_with_plan(self, user_text: str):
         """When user provides feedback during execution, inject plan-aware merge note into manager context."""
         bb = self._ensure_blackboard()
@@ -24900,22 +25829,41 @@ class SessionState:
                 break
         step_desc = trim(str(current_step.get("content", "") if current_step else "none"), 200)
         is_plan_executing = plan.get("phase") == "executing"
+        conflict_score = self._user_feedback_conflict_score(user_text, step_desc)
+        if conflict_score >= 0.8:
+            conflict_level = "HIGH"
+            directive = (
+                "USER OVERRIDE: This feedback DIRECTLY CONFLICTS with the current plan step. "
+                "You MUST prioritize the user's instruction over the original plan. "
+                "Adjust the current step's approach immediately to comply with user's requirement. "
+                "Do NOT continue the original approach."
+            )
+        elif conflict_score >= 0.5:
+            conflict_level = "MEDIUM"
+            directive = (
+                "This feedback modifies the current approach. "
+                "Re-evaluate the current step and adjust delegation to incorporate user's requirement. "
+                "User's direction takes precedence over plan details."
+            )
+        else:
+            conflict_level = "LOW"
+            directive = (
+                "Minor feedback — integrate with current work direction. "
+                "Adjust approach if needed but maintain progress."
+            )
         if is_plan_executing:
             merge_note = (
-                f"<user-feedback-merge>\n"
+                f"<user-feedback-merge conflict=\"{conflict_level}\" score=\"{conflict_score:.2f}\">\n"
                 f"User provided new input during plan execution: {trim(user_text, 500)}\n"
                 f"Current plan step: {step_desc}\n"
-                f"Re-evaluate: Does this feedback change the current step's approach? "
-                f"If yes, adjust delegation accordingly. If it's a new requirement, "
-                f"integrate it into the current or next step. Do NOT restart from scratch.\n"
+                f"{directive}\n"
                 f"</user-feedback-merge>"
             )
         else:
             merge_note = (
-                f"<user-feedback-merge>\n"
+                f"<user-feedback-merge conflict=\"{conflict_level}\" score=\"{conflict_score:.2f}\">\n"
                 f"User provided new input: {trim(user_text, 500)}\n"
-                f"Integrate this feedback with current work direction. "
-                f"Adjust approach if needed but maintain progress.\n"
+                f"{directive}\n"
                 f"</user-feedback-merge>"
             )
         if self._is_multi_agent_mode():
@@ -24925,6 +25873,13 @@ class SessionState:
                 "ts": now_ts(),
                 "agent_role": "manager",
             })
+        else:
+            # single mode: inject directly into message history so the model sees it
+            self.messages.append({
+                "role": "user",
+                "content": merge_note,
+                "ts": now_ts(),
+            })
 
     def _is_restart_scenario(self) -> bool:
         """Check if current state is a restart after finished/aborted task."""
@@ -25006,6 +25961,15 @@ class SessionState:
                 if _awaiting_plan_choice:
                     # Restore plan proposal so choice can be parsed
                     self.runtime_plan_mode_needed = True
+                # Reset completed plan/todo/skills blackboard state so the manager
+                # does not see status=COMPLETED on the very first round and immediately finish.
+                # But preserve plan state if user is continuing an existing task.
+                if not _awaiting_plan_choice:
+                    clean_goal_pre = trim(str(content or "").strip(), 4000)
+                    if self._is_continuation_input(clean_goal_pre):
+                        pass  # Preserve plan state for continuation
+                    else:
+                        self._reset_blackboard_plan_state_locked()
                 self.run_generation = int(self.run_generation) + 1
                 clean_goal = trim(str(content or "").strip(), 4000)
                 self._refresh_runtime_code_reference(clean_goal or content)
@@ -25525,6 +26489,7 @@ class SessionState:
             if self.stall_escalation_triggered:
                 self._emit("status", {"summary": "sync loop break: stall escalated to plan mode"})
                 break
+            self._inject_pending_user_inputs()
             self._apply_auto_compact_if_needed("auto:multi-sync")
             # Periodic checkpoint in multi-agent sync loop
             if rounds_used % CHECKPOINT_INTERVAL_ROUNDS == 0:
@@ -25611,6 +26576,8 @@ class SessionState:
                 media_inputs_round=role_media_inputs,
             )
             self._blackboard_update_from_worker_step(role, step)
+            # Post-execution plan step advancement (replaces pre-execution advancement)
+            self._post_execution_plan_step_check(route, step if isinstance(step, dict) else {})
             # ── Agent turn 结束后的终止检测：结论性回复 + 无待办 + 无错误 → 自动 finish ──
             agent_text = self._latest_agent_assistant_text(role)
             if (
@@ -25890,7 +26857,7 @@ class SessionState:
 
         # Auto-discover and load relevant skills before research
         try:
-            self._refresh_loaded_skills_for_execution_focus(trigger="plan-mode-start")
+            pass  # Skills are loaded on-demand by the model via load_skill
         except Exception:
             pass
 
@@ -25900,12 +26867,22 @@ class SessionState:
         for r in range(PLAN_MODE_EXPLORER_MAX_ROUNDS):
             if self.cancel_requested:
                 return
+            self._inject_pending_user_inputs()
             step = self._plan_mode_explorer_turn(pinned_selection, round_idx=r)
             if step.get("status") in ("no-tools", "skip", "interrupted"):
                 break
             self._plan_mode_update_findings(step)
 
         # Phase 2: Manager 综合分析
+        # Inject pending user inputs before synthesis
+        self._inject_pending_user_inputs()
+        # Check if user sent a substantive goal change during research
+        if self._has_pending_goal_change():
+            self._emit("status", {"summary": "plan-mode: user changed task during research, restarting"})
+            self.runtime_plan_mode_needed = False
+            self.runtime_plan_approved = False
+            return
+
         self._emit("status", {"summary": "plan-mode: synthesizing proposals"})
         bb = self._ensure_blackboard()
         if not isinstance(bb.get("plan"), dict):
@@ -25913,7 +26890,17 @@ class SessionState:
         bb["plan"]["phase"] = "synthesis"
         self.blackboard = bb
 
-        proposal = self._plan_mode_synthesize_proposal(pinned_selection)
+        # Synthesis with retry (up to 2 attempts) + minimal fallback
+        proposal = None
+        for _synth_attempt in range(2):
+            proposal = self._plan_mode_synthesize_proposal(pinned_selection)
+            if proposal and proposal.get("options"):
+                break
+            if _synth_attempt == 0:
+                self._emit("status", {"summary": "plan-mode: synthesis retry"})
+        if not proposal or not proposal.get("options"):
+            # Last resort: minimal fallback with simpler prompt and higher token budget
+            proposal = self._synthesis_minimal_fallback(pinned_selection)
         if not proposal or not proposal.get("options"):
             self._emit("status", {"summary": "plan-mode: synthesis failed, falling back to direct execution"})
             self.runtime_plan_mode_needed = False
@@ -25929,16 +26916,23 @@ class SessionState:
         bb["plan"]["proposal"] = proposal
         self.blackboard = bb
 
-        plan_text = self._format_plan_proposal_markdown(proposal)
+        # Write full plan to file for model consumption
+        try:
+            self._write_plan_file(self._format_plan_file_preselection(proposal))
+        except Exception:
+            pass
+
+        # Condensed bubble for UI (under PLAN_BUBBLE_MAX_CHARS)
+        bubble_text = self._format_plan_bubble_preselection(proposal)
         self.messages.append({
             "role": "assistant",
-            "content": plan_text,
+            "content": bubble_text,
             "ts": now_ts(),
             "agent_role": "planner",
         })
         self._emit("message", {
             "role": "assistant",
-            "text": trim(plan_text, int(ASSISTANT_MESSAGE_EVENT_MAX_CHARS)),
+            "text": trim(bubble_text, int(ASSISTANT_MESSAGE_EVENT_MAX_CHARS)),
             "summary": "plan-mode proposal",
             "agent_role": "planner",
         })
@@ -25973,33 +26967,43 @@ class SessionState:
             f"## User Request\n{goal}\n\n"
             f"{skills_section}"
             f"## Instructions\n"
-            f"1. List all uploaded/workspace files with `ls uploaded/` or `ls` to know what inputs are available\n"
-            f"2. Read uploaded files (.parsed.md preferred over .pdf) to understand their content and structure\n"
-            f"3. If skills are loaded, analyze their <loaded-skill> content to identify concrete workflow steps, "
-            f"scripts, tools, and file paths each skill requires\n"
-            f"4. Identify key technical details, data points, and structure needed for the output\n"
-            f"5. Assess risks and note any ambiguities that need user input\n"
-            f"6. DO NOT write, edit, or create any files. Read-only analysis only.\n"
-            f"7. Write your findings to the blackboard under 'plan_findings'. Include:\n"
+            f"1. Call `list_skills` FIRST to discover available skills — identify which skills are relevant "
+            f"to this task and note their names and capabilities in your findings.\n"
+            f"2. List all uploaded/workspace files with `ls uploaded/` or `ls` to know what inputs are available\n"
+            f"3. Read uploaded files (.parsed.md preferred over .pdf) to understand their content and structure\n"
+            f"4. If relevant skills exist, call `load_skill` to load the most relevant one and analyze its "
+            f"workflow steps, scripts, tools, and file paths\n"
+            f"5. Identify key technical details, data points, and structure needed for the output\n"
+            f"6. Assess risks and note any ambiguities that need user input\n"
+            f"7. DO NOT write, edit, or create any files. Read-only analysis only.\n"
+            f"8. Write your findings to the blackboard under 'plan_findings'. Include:\n"
+            f"   - Relevant skills found (names, what they do, how to invoke them)\n"
             f"   - File inventory (uploaded files, their types, sizes, key content)\n"
-            f"   - Skill workflow breakdown (concrete tools, scripts, paths for each loaded skill)\n"
-            f"   - Content analysis (key themes, structure, data points extracted from inputs)\n\n"
-            f"Workspace: {self.files_root}\n"
+            f"   - Skill workflow breakdown (concrete tools, scripts, paths for each relevant skill)\n"
+            f"   - Content analysis (key themes, structure, data points extracted from inputs)\n"
+            f"9. For coding tasks, identify the test strategy:\n"
+            f"   - What build/compilation commands are available? (Makefile, npm, cargo, cmake, etc.)\n"
+            f"   - What test frameworks/suites exist? (pytest, jest, go test, etc.)\n"
+            f"   - What are the critical paths that must be tested?\n"
+            f"   - Record these in plan_findings under 'test_strategy'.\n\n"
+            f"Workspace: \"{self.files_root}\" ($SESSION_ROOT)\n"
             f"{os_note}\n"
             f"{lang_note}"
         )
 
     def _seed_plan_mode_explorer_context(self, research_prompt: str):
         os_note = _detect_os_shell_instruction()
-        skills_hint = self._loaded_skills_prompt_hint(for_role="explorer")
+        skills_block = self._skills_awareness_block(for_role="explorer")
         self._append_agent_context_message("explorer", {
             "role": "system",
             "content": (
                 "You are Explorer in plan-mode (read-only research). "
                 "Analyze the codebase to understand the task scope. "
                 "Do NOT modify any files. Use read_file, bash (read-only commands), "
-                "and blackboard tools only. "
-                f"{skills_hint}"
+                "list_skills, load_skill, and blackboard tools only. "
+                f"{skills_block}"
+                "IMPORTANT: If the task requires specialized output (PPTX, reports, deep research, code review), "
+                "call list_skills first to discover relevant skills, then note in plan_findings which skills to use. "
                 f"{os_note} "
                 f"{model_language_instruction(self.ui_language)}"
             ),
@@ -26030,16 +27034,16 @@ class SessionState:
             self.current_phase = f"plan-mode:explorer:round-{round_idx}"
             self.current_tool_name = ""
             self.active_agent_role = "explorer"
-        # Build loaded-skills hint for system prompt
-        skills_hint = self._loaded_skills_prompt_hint(for_role="explorer")
+        # Build skills awareness block (same as sync/single mode)
+        skills_block = self._skills_awareness_block(for_role="explorer")
         response = self._chat_with_same_model_retry(
             ctx,
             tools=filtered_tools,
             system=(
                 "You are Explorer in plan-mode research. Read-only analysis. "
                 "Do NOT create, write, or edit files. "
-                f"Workspace: {self.files_root}. "
-                f"{skills_hint}"
+                f"Workspace: \"{self.files_root}\" ($SESSION_ROOT). "
+                f"{skills_block}"
                 f"{_detect_os_shell_instruction()} "
                 f"{model_language_instruction(self.ui_language)}"
             ),
@@ -26443,12 +27447,22 @@ class SessionState:
             f"- Each step should be completable in 1-3 tool calls\n"
             f"- Group related substeps under numbered headings (e.g., '2.1 Read report 1', '2.2 Read report 2')\n"
             f"Make options meaningfully different (e.g. different approaches, scope levels, or trade-offs).\n"
-            f"{model_language_instruction(self.ui_language)}"
-        )
+            "\nVERIFICATION & TESTING:\n"
+            "Judge from the task content and research findings whether the task involves writing, "
+            "modifying, or generating code/scripts/configurations. If it does:\n"
+            "- Include compile/build/lint verification steps after implementation steps.\n"
+            "- Include a dedicated testing step with specific commands before final review.\n"
+            "- For large plans (10+ steps), insert intermediate test checkpoints.\n"
+            "- If the task modifies existing code, include a regression test step.\n"
+            "If the task is pure research, analysis, or document generation with no executable code, "
+            "skip compile/test steps — use your judgement.\n"
+        )
+        synthesis_prompt += f"{model_language_instruction(self.ui_language)}"
         synthesis_ctx = [
             {"role": "system", "content": (
                 "You are a technical architect synthesizing research into actionable plans. "
-                "When loaded skills are available, incorporate their capabilities and best practices into plan options."
+                "When skills are referenced in the findings, incorporate their actual workflow steps into plan options. "
+                f"{self._skills_awareness_block(for_role='developer')}"
             ), "ts": now_ts()},
             {"role": "user", "content": synthesis_prompt, "ts": now_ts()},
         ]
@@ -26472,6 +27486,63 @@ class SessionState:
                     return dict(args)
         return {}
 
+    def _synthesis_minimal_fallback(self, pinned_selection: str) -> dict:
+        """Last-resort: ask model for a single simple plan with higher max_tokens."""
+        goal = trim(str(self.runtime_reclassify_goal or self._latest_user_goal_text() or ""), 2000)
+        bb = self._ensure_blackboard()
+        findings = bb.get("plan", {}).get("findings", []) if isinstance(bb.get("plan"), dict) else []
+        findings_text = "\n".join(
+            trim(str(f.get("content", "") if isinstance(f, dict) else ""), 600)
+            for f in (findings[:5] if isinstance(findings, list) else [])
+        )
+        prompt = (
+            f"Generate ONE simple plan for this task. Call submit_plan_proposal with exactly 1 option.\n\n"
+            f"Task: {goal}\n\nFindings: {trim(findings_text, 3000)}\n\n"
+            f"Return a single option with id='A', title, summary, and 5-10 concrete steps.\n"
+            f"{model_language_instruction(self.ui_language)}"
+        )
+        ctx = [
+            {"role": "system", "content": "You must call submit_plan_proposal tool.", "ts": now_ts()},
+            {"role": "user", "content": prompt, "ts": now_ts()},
+        ]
+        try:
+            response = self._chat_with_same_model_retry(
+                ctx,
+                tools=self._plan_mode_synthesis_tools(),
+                system="Call submit_plan_proposal now.",
+                max_tokens=6000,
+                think=False,
+                stream_thinking=False,
+                on_thinking_chunk=self._append_live_thinking,
+                pinned_selection=pinned_selection,
+                context_label="plan-mode minimal fallback",
+                retries=2,
+            )
+            for tc in response.get("tool_calls", []):
+                if tc.get("function", {}).get("name") == "submit_plan_proposal":
+                    args = tc["function"].get("arguments", {})
+                    if isinstance(args, dict) and args.get("options"):
+                        return dict(args)
+        except Exception:
+            pass
+        return {}
+
+    def _has_pending_goal_change(self) -> bool:
+        """Check if user sent a substantive goal change (not just plan choice or continuation)."""
+        with self.lock:
+            for row in self.pending_user_inputs:
+                content = str(row.get("content", "") or "").strip().lower()
+                if not content:
+                    continue
+                if content in {
+                    "继续", "continue", "go on", "接着", "a", "b", "c",
+                    "方案a", "方案b", "方案c", "keep going", "proceed",
+                }:
+                    continue
+                if len(content) > 10:
+                    return True
+        return False
+
     def _plan_mode_synthesis_tools(self) -> list:
         return [tool_def(
             "submit_plan_proposal",
@@ -26499,6 +27570,185 @@ class SessionState:
             ["context", "options", "recommended"],
         )]
 
+    # ── Plan MD File helpers ──────────────────────────────────────────
+
+    def _plan_file_path(self) -> Path:
+        """Plan MD file path (inside files_root sandbox, accessible via read_file)."""
+        return self.files_root / ".clouds_coder" / "plan.md"
+
+    def _write_plan_file(self, content: str) -> bool:
+        """Atomically write plan.md: write tmp → os.replace."""
+        import uuid as _uuid_mod
+        target = self._plan_file_path()
+        target.parent.mkdir(parents=True, exist_ok=True)
+        tmp = target.with_suffix(f".{_uuid_mod.uuid4().hex[:8]}.tmp")
+        try:
+            tmp.write_text(content, encoding="utf-8")
+            os.replace(str(tmp), str(target))
+            return True
+        except Exception:
+            try:
+                tmp.unlink(missing_ok=True)
+            except Exception:
+                pass
+            return False
+
+    def _read_plan_file(self) -> str:
+        """Read plan.md; returns empty string if file does not exist."""
+        try:
+            p = self._plan_file_path()
+            return p.read_text(encoding="utf-8") if p.exists() else ""
+        except Exception:
+            return ""
+
+    def _format_plan_file_preselection(self, proposal: dict) -> str:
+        """Full MD content with ALL options for model review (no char limit)."""
+        lines = ["# Execution Plan Proposals\n"]
+        context = str(proposal.get("context", "") or "").strip()
+        if context:
+            lines.append(f"## Background\n{context}\n")
+        recommended = str(proposal.get("recommended", "") or "").strip()
+        options = proposal.get("options", [])
+        if not isinstance(options, list):
+            options = []
+        for opt in options[:PLAN_MODE_MAX_OPTIONS]:
+            if not isinstance(opt, dict):
+                continue
+            opt_id = str(opt.get("id", "") or "").strip()
+            title = str(opt.get("title", "") or "").strip()
+            header = f"## Option {opt_id}: {title}"
+            if opt_id == recommended:
+                header += " [RECOMMENDED]"
+            lines.append("---\n")
+            lines.append(header)
+            summary = str(opt.get("summary", "") or "").strip()
+            if summary:
+                lines.append(summary)
+            steps = opt.get("steps", [])
+            if isinstance(steps, list) and steps:
+                lines.append("\n### Steps")
+                for i, s in enumerate(steps):
+                    lines.append(f"{i + 1}. {s}")
+            pros = str(opt.get("pros", "") or "").strip()
+            if pros:
+                lines.append(f"\n**Pros:** {pros}")
+            cons = str(opt.get("cons", "") or "").strip()
+            if cons:
+                lines.append(f"**Cons:** {cons}")
+            risk = str(opt.get("risk", "") or "").strip()
+            if risk:
+                lines.append(f"**Risk:** {risk}")
+            lines.append("")
+        lines.append("---")
+        lines.append("> Awaiting user choice.")
+        return "\n".join(lines)
+
+    def _format_plan_file_execution(self, choice_id: str) -> str:
+        """Render execution-phase plan.md with live step statuses from blackboard."""
+        bb = self._ensure_blackboard()
+        proposal = self.runtime_plan_proposal or {}
+        chosen = next(
+            (o for o in proposal.get("options", [])
+             if isinstance(o, dict) and o.get("id") == choice_id),
+            None,
+        )
+        title = str((chosen or {}).get("title", "") or choice_id).strip()
+        summary = str((chosen or {}).get("summary", "") or "").strip()
+        todos = bb.get("project_todos", [])
+        plan_todos = [t for t in todos if t.get("category") == "plan_step"]
+        total = len(plan_todos)
+        completed = sum(1 for t in plan_todos if t.get("status") == "completed")
+        current_idx = completed + 1
+
+        lines = [f"# Active Plan: {title}\n"]
+        lines.append(f"> Status: EXECUTING | Step {current_idx}/{total}")
+        lines.append(f"> Chosen: Option {choice_id}")
+        from datetime import datetime as _dt_cls
+        lines.append(f"> Updated: {_dt_cls.now().isoformat(timespec='seconds')}\n")
+        if summary:
+            lines.append(f"## Summary\n{summary}\n")
+        lines.append("## Steps\n")
+        for t in plan_todos:
+            idx = int(t.get("plan_step_index", 0) or 0) + 1
+            text = str(t.get("content", "") or "").strip()
+            status = str(t.get("status", "pending") or "pending")
+            if status == "completed":
+                actor = str(t.get("completed_by", "") or "")
+                evidence = str(t.get("evidence", "") or "")
+                lines.append(f"- [x] Step {idx}: {text}")
+                meta_parts = []
+                if actor:
+                    meta_parts.append(f"Completed by: {actor}")
+                if evidence:
+                    meta_parts.append(f"Evidence: {evidence}")
+                if meta_parts:
+                    lines.append(f"  > {' | '.join(meta_parts)}")
+            elif status == "in_progress":
+                lines.append(f"- [>] Step {idx}: {text}  <-- CURRENT")
+            else:
+                lines.append(f"- [ ] Step {idx}: {text}")
+        return "\n".join(lines) + "\n"
+
+    def _update_plan_file_step_status(self) -> bool:
+        """Re-render execution-phase plan.md from current blackboard state and write atomically."""
+        choice_id = str(self.runtime_plan_choice or "")
+        if not choice_id:
+            bb = self._ensure_blackboard()
+            plan_data = bb.get("plan", {})
+            choice_id = str(plan_data.get("chosen", "") if isinstance(plan_data, dict) else "")
+        if not choice_id:
+            return False
+        content = self._format_plan_file_execution(choice_id)
+        return self._write_plan_file(content)
+
+    def _format_plan_bubble_preselection(self, proposal: dict) -> str:
+        """Condensed bubble for UI (under PLAN_BUBBLE_MAX_CHARS). No full step listing."""
+        lines = ["## 📋 执行方案\n"]
+        context = str(proposal.get("context", "") or "").strip()
+        if context:
+            lines.append(f"**背景：** {trim(context, 300)}\n")
+        recommended = str(proposal.get("recommended", "") or "").strip()
+        options = proposal.get("options", [])
+        if not isinstance(options, list):
+            options = []
+        for opt in options[:PLAN_MODE_MAX_OPTIONS]:
+            if not isinstance(opt, dict):
+                continue
+            opt_id = str(opt.get("id", "") or "").strip()
+            title = str(opt.get("title", "") or "").strip()
+            is_rec = opt_id == recommended
+            header = f"### 方案 {opt_id}: {title}"
+            if is_rec:
+                header += " ⭐推荐"
+            lines.append(header)
+            summary = str(opt.get("summary", "") or "").strip()
+            if summary:
+                lines.append(trim(summary, 200))
+            steps = opt.get("steps", [])
+            step_count = len(steps) if isinstance(steps, list) else 0
+            risk = str(opt.get("risk", "") or "").strip()
+            meta = f"步骤数: {step_count}"
+            if risk:
+                meta += f" | 风险: {risk}"
+            lines.append(meta)
+            lines.append("")
+        lines.append("---")
+        lines.append(f"完整方案详见: `{PLAN_FILE_RELATIVE_PATH}`")
+        lines.append('请回复选择（如"方案A"、"A"、"选1"），或输入修改意见。')
+        return trim("\n".join(lines), PLAN_BUBBLE_MAX_CHARS)
+
+    def _plan_file_read_instruction(self) -> str:
+        """Short instruction for models: read the plan file instead of embedding full plan text."""
+        return (
+            f"[plan-file] The approved execution plan is at `{PLAN_FILE_RELATIVE_PATH}`.\n"
+            f"Use: read_file {PLAN_FILE_RELATIVE_PATH} to review full steps and live status.\n"
+            "The plan file is the authoritative source for step ordering and completion status.\n"
+            "Execute steps IN ORDER. Do NOT skip ahead. Mark current step done before advancing.\n"
+            "If a step references a skill or workflow, call load_skill to load it before proceeding."
+        )
+
+    # ── (legacy) _format_plan_proposal_markdown ──────────────────────
+
     def _format_plan_proposal_markdown(self, proposal: dict) -> str:
         lines = ["## 📋 执行方案\n"]
         context = str(proposal.get("context", "") or "").strip()
@@ -26624,16 +27874,9 @@ class SessionState:
         )
         if not chosen:
             return
-        steps_text = "\n".join(f"{i+1}. {s}" for i, s in enumerate(chosen.get("steps", [])))
-        plan_msg = (
-            f"[approved-plan] Execute the following plan:\n"
-            f"## {chosen.get('title', '')}\n"
-            f"{chosen.get('summary', '')}\n\n"
-            f"### Steps:\n{steps_text}\n\n"
-            f"Follow these steps. Use tools to implement each step concretely.\n"
-            f"If a step references a skill or workflow you don't fully understand, "
-            f"call load_skill to load it and read its instructions before proceeding."
-        )
+        # Write execution-phase plan file (detailed, for model read_file)
+        # Must happen BEFORE blackboard todos are created so the file reflects initial state
+        plan_msg = self._plan_file_read_instruction()
         self.messages.append({
             "role": "system",
             "content": plan_msg,
@@ -26651,6 +27894,9 @@ class SessionState:
         bb["plan"] = {"phase": "executing", "chosen": choice_id, "steps": chosen.get("steps", [])}
         self.blackboard = bb
         self._blackboard_history("manager", f"plan approved: option {choice_id} — {chosen.get('title', '')}")
+        # Lock complexity/level floor to prevent manager downgrade during plan execution
+        self.runtime_complexity_floor = str(self.runtime_task_complexity or "complex")
+        self.runtime_task_level_floor = int(self.runtime_task_level or 4)
         # Auto-create todos from plan steps → write into bb["project_todos"]
         steps = chosen.get("steps", [])
         if steps and isinstance(steps, list):
@@ -26671,7 +27917,7 @@ class SessionState:
                     "evidence": "",
                 })
             if plan_todos:
-                bb["project_todos"] = plan_todos[:20]
+                bb["project_todos"] = plan_todos[:40]
                 bb["plan_step_cursor"] = 0
                 bb["plan_step_total"] = len(plan_todos)
                 self.blackboard = bb
@@ -26686,12 +27932,13 @@ class SessionState:
                             "status": t["status"],
                             "activeForm": f"Working on: {t['content']}" if t["status"] == "in_progress" else f"Pending: {t['content']}",
                         }
-                        for t in plan_todos[:20]
+                        for t in plan_todos[:40]
                     ])
                 except Exception:
                     pass
+        # Write execution-phase plan file (now with todos populated)
         try:
-            self._refresh_loaded_skills_for_execution_focus(trigger="plan-approved")
+            self._write_plan_file(self._format_plan_file_execution(choice_id))
         except Exception:
             pass
         # Pre-load skills explicitly mentioned in plan steps
@@ -26755,13 +28002,13 @@ class SessionState:
                     )
                 },
             )
-            # ── Auto-discover and load relevant skills BEFORE classification ──
+            # ── Skills are loaded on-demand by the model via load_skill ──
             try:
                 self._emit(
                     "status",
-                    {"summary": "initial skill discovery started"},
+                    {"summary": "skills available on-demand"},
                 )
-                self._refresh_loaded_skills_for_execution_focus(trigger="pre-classify")
+                pass  # No automatic pre-classify skill discovery
             except Exception:
                 pass
             initial_policy_media_inputs = self._recent_multimodal_inputs()
@@ -29781,6 +31028,9 @@ h3{font-size:.96rem;margin:10px 0 6px}
 .todo-item,.task-item{border:1px solid #e4ebf4;border-left-width:4px;border-radius:10px;padding:8px 10px;background:#fcfdff}
 .todo-item.st-pending,.task-item.st-pending{border-left-color:#7b8798}
 .todo-item.st-in_progress,.task-item.st-in_progress{border-left-color:#1f6feb;background:#eef5ff}
+.todo-group-label{font-size:.72rem;font-weight:600;color:var(--muted);text-transform:uppercase;letter-spacing:.04em;margin:6px 0 2px 2px}
+.todo-subtask{margin-left:16px;border-left-width:3px;border-radius:8px;padding:6px 10px;font-size:.9em}
+.todo-subtask::before{content:"↳ ";color:var(--muted);font-size:.85em}
 .todo-item.st-completed,.task-item.st-completed{border-left-color:#13b8a6;background:#edfcf7}
 .todo-item.st-blocked,.task-item.st-blocked{border-left-color:#b96b00;background:#fff6ea}
 .todo-item.st-deleted,.task-item.st-deleted{border-left-color:#a0a6b0;background:#f7f8fa}
@@ -29939,7 +31189,8 @@ const I18N={
     llm_fill_config:'Fill LLM Config',llm_provider:'Provider',llm_confirm:'Confirm',llm_import_config:'Import config',
     llm_thinking_stream:'Thinking Stream',llm_enabled:'Enabled',llm_disabled:'Disabled',
     llm_model:'Model',llm_scan:'Scan',llm_scan_hint:'Click Scan to detect models from Ollama',llm_scan_first:'Scan models first',
-    llm_scanning:'Scanning...',llm_scan_found:'Found {n} model(s)',llm_scan_empty:'No models found',llm_scan_error:'Scan failed'
+    llm_scanning:'Scanning...',llm_scan_found:'Found {n} model(s)',llm_scan_empty:'No models found',llm_scan_error:'Scan failed',
+    todo_plan_steps:'Plan Steps',todo_subtasks:'Subtasks'
   },
   'zh-CN':{
     app_title:'Clouds Coder',app_subtitle:'WebUI 驱动的会话式集成编程 Agent 平台',powered_by:'Powered By Fona',
@@ -29974,7 +31225,8 @@ const I18N={
     llm_fill_config:'填写 LLM 配置',llm_provider:'供应商',llm_confirm:'确认',llm_import_config:'导入配置',
     llm_thinking_stream:'思维流',llm_enabled:'启用',llm_disabled:'禁用',
     llm_model:'模型',llm_scan:'扫描',llm_scan_hint:'点击扫描检测 Ollama 可用模型',llm_scan_first:'请先扫描模型',
-    llm_scanning:'扫描中...',llm_scan_found:'发现 {n} 个模型',llm_scan_empty:'未发现模型',llm_scan_error:'扫描失败'
+    llm_scanning:'扫描中...',llm_scan_found:'发现 {n} 个模型',llm_scan_empty:'未发现模型',llm_scan_error:'扫描失败',
+    todo_plan_steps:'计划步骤',todo_subtasks:'子任务'
   },
   'zh-TW':{
     app_title:'Clouds Coder',app_subtitle:'WebUI 驅動的會話式整合程式 Agent 平台',powered_by:'Powered By Fona',
@@ -30009,7 +31261,8 @@ const I18N={
     llm_fill_config:'填寫 LLM 設定',llm_provider:'供應商',llm_confirm:'確認',llm_import_config:'匯入設定',
     llm_thinking_stream:'思維流',llm_enabled:'啟用',llm_disabled:'停用',
     llm_model:'模型',llm_scan:'掃描',llm_scan_hint:'點擊掃描偵測 Ollama 可用模型',llm_scan_first:'請先掃描模型',
-    llm_scanning:'掃描中...',llm_scan_found:'發現 {n} 個模型',llm_scan_empty:'未發現模型',llm_scan_error:'掃描失敗'
+    llm_scanning:'掃描中...',llm_scan_found:'發現 {n} 個模型',llm_scan_empty:'未發現模型',llm_scan_error:'掃描失敗',
+    todo_plan_steps:'計劃步驟',todo_subtasks:'子任務'
   },
   'ja':{
     app_title:'Clouds Coder',app_subtitle:'WebUI 駆動の対話型コーディング Agent プラットフォーム',powered_by:'Powered By Fona',
@@ -30044,7 +31297,8 @@ const I18N={
     llm_fill_config:'LLM設定入力',llm_provider:'プロバイダー',llm_confirm:'確認',llm_import_config:'設定をインポート',
     llm_thinking_stream:'シンキングストリーム',llm_enabled:'有効',llm_disabled:'無効',
     llm_model:'モデル',llm_scan:'スキャン',llm_scan_hint:'スキャンをクリックしてOllamaモデルを検出',llm_scan_first:'先にモデルをスキャン',
-    llm_scanning:'スキャン中...',llm_scan_found:'{n}個のモデルを検出',llm_scan_empty:'モデルが見つかりません',llm_scan_error:'スキャン失敗'
+    llm_scanning:'スキャン中...',llm_scan_found:'{n}個のモデルを検出',llm_scan_empty:'モデルが見つかりません',llm_scan_error:'スキャン失敗',
+    todo_plan_steps:'計画ステップ',todo_subtasks:'サブタスク'
   }
 };
 function currentLang(){const fromSnap=String(S.snap?.ui_language||'').trim();if(fromSnap&&I18N[fromSnap])return fromSnap;const fromCfg=String(S.config?.language||'').trim();if(fromCfg&&I18N[fromCfg])return fromCfg;return 'zh-CN'}
@@ -30581,16 +31835,32 @@ function _mathRunTypeset(root,key=''){
   if(!root)return;
   const k=String(key||'').trim();
   if(k&&root.getAttribute('data-math-key')===k)return;
+  const mathJaxCandidates=[
+    '/assets/js_lib/tex-mml-chtml.js',
+    '/assets/js_lib/mathjax/tex-mml-chtml.js',
+    '/assets/js_lib/es5/tex-mml-chtml.js',
+    '/assets/js_lib/mathjax/es5/tex-mml-chtml.js',
+    'https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js'
+  ];
+  const loadMathJax=(idx=0)=>{
+    const src=String(mathJaxCandidates[idx]||'').trim();
+    if(!src)return;
+    const s=document.createElement('script');
+    s.src=src;
+    s.async=true;
+    s.dataset.mathjaxCandidate=String(idx);
+    s.onerror=()=>{
+      if(idx+1<mathJaxCandidates.length)loadMathJax(idx+1);
+    };
+    document.head.appendChild(s);
+  };
   const run=(retry)=>{
     const mj=window.MathJax;
     if(!mj||typeof mj.typesetPromise!=='function'){
       // Lazy-load MathJax on first actual math demand
       if(!window._mjaxLoading){
         window._mjaxLoading=true;
-        const s=document.createElement('script');
-        s.src='https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js';
-        s.async=true;
-        document.head.appendChild(s);
+        loadMathJax(0);
       }
       if(retry<20)setTimeout(()=>run(retry+1),200);
       return;
@@ -32339,7 +33609,54 @@ function statusClass(status){return `st-${normalizeStatus(status)}`}
 function statusLabel(status){const s=normalizeStatus(status);if(s==='in_progress')return t('status_in_progress');if(s==='completed')return t('status_completed');if(s==='blocked')return t('status_blocked');if(s==='deleted')return t('status_deleted');return t('status_pending')}
 function cleanWorkText(text,status=''){let s=String(text??'').replace(/\\s+/g,' ').trim();if(!s)return '';s=s.replace(/^\\[[ x>\\-]\\]\\s*/i,'');s=s.replace(/^(pending|in[_\\-\\s]?progress|completed|done|blocked)\\s*[·:\\-\\]]\\s*/i,'');if(status){const st=String(status).replace('_','[_\\\\-\\\\s]?');s=s.replace(new RegExp(`\\\\s*[—-]\\\\s*${st}\\\\s*$`,'i'),'')}s=s.replace(/\\s*[—-]\\s*(pending|in[_\\-\\s]?progress|completed|done|blocked)\\s*$/i,'');return s.trim()||String(text??'').trim()}
 function formatTs(ts){const v=Number(ts||0);if(!v)return '';try{return new Date(v*1000).toLocaleString()}catch(_){return ''}}
-function renderTodoBoard(items){const todos=Array.isArray(items)?items:[];if(!todos.length)return `<div class=\"mono\">${esc(t('no_todos'))}</div>`;const done=todos.filter(t=>normalizeStatus(t?.status)==='completed').length;const open=todos.length-done;const cards=todos.map((t,idx)=>{const status=normalizeStatus(t?.status);const content=cleanWorkText(t?.content,status)||'(empty todo)';const active=String(t?.activeForm||'').trim();const meta=status==='in_progress'&&active?`<div class=\"todo-meta\">${esc(cleanWorkText(active,status))}</div>`:'';return `<div class=\"todo-item ${statusClass(status)}\"><div class=\"todo-head\"><span class=\"status-badge ${statusClass(status)}\">${esc(statusLabel(status))}</span><span class=\"mono todo-index\">#${idx+1}</span></div><div class=\"todo-content\">${esc(content)}</div>${meta}</div>`}).join('');return `<div class=\"board-summary\"><span>${esc(open)} ${esc(t('open'))}</span><span>${esc(done)}/${esc(todos.length)} ${esc(t('completed'))}</span></div><div class=\"todo-list\">${cards}</div>`}
+function renderTodoBoard(items){
+  const todos=Array.isArray(items)?items:[];
+  if(!todos.length)return `<div class="mono">${esc(t('no_todos'))}</div>`;
+  const done=todos.filter(x=>normalizeStatus(x?.status)==='completed').length;
+  const open=todos.length-done;
+  function todoCard(item,idx,extraClass=''){
+    const status=normalizeStatus(item?.status);
+    const content=cleanWorkText(item?.content,status)||'(empty todo)';
+    const active=String(item?.activeForm||'').trim();
+    const meta=status==='in_progress'&&active?`<div class="todo-meta">${esc(cleanWorkText(active,status))}</div>`:'';
+    return `<div class="todo-item ${statusClass(status)}${extraClass?(' '+extraClass):''}"><div class="todo-head"><span class="status-badge ${statusClass(status)}">${esc(statusLabel(status))}</span><span class="mono todo-index">#${idx+1}</span></div><div class="todo-content">${esc(content)}</div>${meta}</div>`;
+  }
+  // Split into plan steps (bb:proj:) and worker subtasks
+  const planSteps=todos.filter(x=>String(x?.key||'').startsWith('bb:proj:'));
+  const workerTodos=todos.filter(x=>!String(x?.key||'').startsWith('bb:proj:'));
+  let html='';
+  if(planSteps.length&&workerTodos.length){
+    // Build parent_step_id index: map step key suffix to its subtasks
+    const stepIdFromKey=(key)=>{const k=String(key||'');return k.startsWith('bb:proj:')?k.slice(8):''};
+    const subtasksByStep={};
+    const unlinked=[];
+    workerTodos.forEach(sub=>{
+      const pid=String(sub?.parent_step_id||'').trim();
+      if(pid){(subtasksByStep[pid]=subtasksByStep[pid]||[]).push(sub)}
+      else{unlinked.push(sub)}
+    });
+    // Find active plan step for unlinked subtasks fallback
+    const activeStepIdx=planSteps.findIndex(x=>normalizeStatus(x?.status)==='in_progress');
+    html+=`<div class="todo-group-label">${esc(t('todo_plan_steps'))}</div><div class="todo-list">`;
+    planSteps.forEach((step,i)=>{
+      html+=todoCard(step,i);
+      const sid=stepIdFromKey(step?.key);
+      // Show subtasks linked to this step via parent_step_id
+      const linked=sid?subtasksByStep[sid]||[]:[];
+      // Also attach unlinked subtasks under the active plan step (backward compat)
+      const subs=i===activeStepIdx?linked.concat(unlinked):linked;
+      if(subs.length){
+        html+=`<div class="todo-group-label" style="margin-left:16px">${esc(t('todo_subtasks'))}</div>`;
+        subs.forEach((sub,j)=>{html+=todoCard(sub,j,'todo-subtask')});
+      }
+    });
+    html+=`</div>`;
+  } else {
+    // No grouping needed — flat list
+    html+=`<div class="todo-list">${todos.map((x,i)=>todoCard(x,i)).join('')}</div>`;
+  }
+  return `<div class="board-summary"><span>${esc(open)} ${esc(t('open'))}</span><span>${esc(done)}/${esc(todos.length)} ${esc(t('completed'))}</span></div>${html}`;
+}
 function renderTaskBoard(items){const tasks=Array.isArray(items)?items:[];if(!tasks.length)return `<div class=\"mono\">${esc(t('no_tasks'))}</div>`;const completed=tasks.filter(row=>normalizeStatus(row?.status,'pending')==='completed').length;const blocked=tasks.filter(row=>normalizeStatus(row?.status,'pending')==='blocked').length;const cards=tasks.map(row=>{const status=normalizeStatus(row?.status,'pending');const id=Number(row?.id||0)||'-';const subject=cleanWorkText(row?.subject,status)||'(empty task)';const owner=String(row?.owner||'').trim();const blockedBy=Array.isArray(row?.blockedBy)&&row.blockedBy.length?`blocked_by=${row.blockedBy.map(x=>`#${x}`).join(', ')}`:'';const blocks=Array.isArray(row?.blocks)&&row.blocks.length?`blocks=${row.blocks.map(x=>`#${x}`).join(', ')}`:'';const timeTxt=formatTs(row?.updated_at||row?.created_at);const meta=[owner?`owner=@${owner}`:t('owner_unassigned'),blockedBy,blocks,timeTxt].filter(Boolean).join(' · ');return `<div class=\"task-item ${statusClass(status)}\"><div class=\"task-head\"><span class=\"mono task-id\">#${esc(id)}</span><span class=\"status-badge ${statusClass(status)}\">${esc(statusLabel(status))}</span></div><div class=\"task-subject\">${esc(subject)}</div><div class=\"task-meta\">${esc(meta)}</div></div>`}).join('');return `<div class=\"board-summary\"><span>${esc(tasks.length-completed)} ${esc(t('open'))}</span><span>${esc(completed)} ${esc(t('completed'))} · ${esc(blocked)} ${esc(t('blocked'))}</span></div><div class=\"task-list\">${cards}</div>`}
 function ensureFileExplorerState(sessionId){const sid=String(sessionId||S.activeId||'').trim();if(!sid)return null;if(!S.fileExplorerBySession)S.fileExplorerBySession={};if(!S.fileExplorerBySession[sid]||typeof S.fileExplorerBySession[sid]!=='object'){S.fileExplorerBySession[sid]={tree:null,root:'',nodeCount:0,truncated:false,maxNodes:0,fetchedAt:0,inflight:false,selected:'',expanded:{'':true}}}const st=S.fileExplorerBySession[sid];if(!st.expanded||typeof st.expanded!=='object')st.expanded={'':true};st.expanded['']=true;return st}
 function _fePath(sessionId){const sid=encodeURIComponent(String(sessionId||'').trim());return `/api/sessions/${sid}/files-tree`}
@@ -34349,7 +35666,7 @@ class RAGContentParser:
 
             text = extract_text(str(pdf_path))
             if text and text.strip():
-                return trim(text.strip(), 150_000)
+                return trim(text.strip(), 800_000)
         except ImportError:
             pass
         except Exception:
@@ -34364,7 +35681,7 @@ class RAGContentParser:
                     timeout=60,
                 )
                 if r.returncode == 0 and r.stdout.strip():
-                    return trim(r.stdout.strip(), 150_000)
+                    return trim(r.stdout.strip(), 800_000)
             except Exception:
                 pass
         try:
@@ -36525,7 +37842,7 @@ class RAGLibraryStore:
             backup_path.write_bytes(raw_bytes)
         elif source_fp and source_fp.exists():
             shutil.copy2(source_fp, backup_path)
-        semantic_text = trim(str(parse_result.get("text", "") or ""), 160_000)
+        semantic_text = trim(str(parse_result.get("text", "") or ""), 800_000)
         multimodal_row = dict(multimodal or {})
         mm_summary = trim(str(multimodal_row.get("summary", "") or ""), 2400)
         mm_tags = [str(x).strip() for x in (multimodal_row.get("tags", []) or []) if str(x).strip()]
@@ -39952,20 +41269,12 @@ class AppContext:
         self.base_url = base_url
         self.model = model
         self.thinking = False
-        self.js_lib_root = offline_js_lib_root(self.workspace)
+        self.js_lib_root = offline_js_lib_root(SCRIPT_DIR)
         self.offline_js_summary: dict = {}
         try:
-            self.offline_js_summary = ensure_offline_js_libs(self.workspace, force=False)
-        except Exception as exc:
-            self.offline_js_summary = {
-                "generated_at": int(now_ts()),
-                "js_lib_root": str(self.js_lib_root),
-                "total": len(OFFLINE_JS_LIB_CATALOG),
-                "available": 0,
-                "missing": len(OFFLINE_JS_LIB_CATALOG),
-                "fetched": 0,
-                "error": trim(str(exc), 220),
-            }
+            self.offline_js_summary = load_offline_js_lib_index(self.js_lib_root)
+        except Exception:
+            self.offline_js_summary = {}
         self.default_language = normalize_ui_language(default_language)
         self.ui_style = normalize_ui_style(ui_style)
         self.context_token_limit = max(
@@ -40264,16 +41573,7 @@ class AppContext:
         return CODE_ADMIN_JS
 
     def rag_js_lib_asset_path(self, filename: str) -> Path | None:
-        safe = _safe_js_filename(str(filename or "").strip(), "lib.js")
-        fp = (self.js_lib_root / safe).resolve()
-        try:
-            if not fp.is_relative_to(self.js_lib_root):
-                return None
-        except Exception:
-            return None
-        if not fp.exists() or (not fp.is_file()):
-            return None
-        return fp
+        return _resolve_js_lib_asset_path(self.js_lib_root, str(filename or "").strip())
 
     def rag_three_asset_info(self) -> dict:
         picks = [
@@ -41071,7 +42371,7 @@ class AppContext:
                 f"{str(row.get('title', '') or '').strip()} "
                 f"score={str(row.get('score', 0) or 0)}"
             )
-            snippet = trim(str(row.get("text", "") or ""), 320)
+            snippet = trim(str(row.get("text", "") or ""), 800)
             if snippet:
                 lines.append(snippet)
         return "\n".join(lines)
@@ -43150,8 +44450,8 @@ class RagAdminHandler(BaseHTTPRequestHandler):
         if path == "/assets/rag-admin.js":
             return self._send_text(self.app.web_ui_rag_admin_js(), "application/javascript; charset=utf-8")
         if path.startswith("/assets/js_lib/"):
-            filename = path.rsplit("/", 1)[-1]
-            fp = self.app.rag_js_lib_asset_path(filename)
+            asset_ref = path[len("/assets/js_lib/"):]
+            fp = self.app.rag_js_lib_asset_path(asset_ref)
             if not fp:
                 return self._send_json({"error": "asset not found"}, status=404)
             try:
@@ -43159,7 +44459,7 @@ class RagAdminHandler(BaseHTTPRequestHandler):
             except Exception as exc:
                 return self._send_json({"error": str(exc)}, status=500)
             content_type = guess_mime_from_name(fp.name, "application/javascript")
-            if fp.suffix.lower() == ".js":
+            if fp.suffix.lower() in {".js", ".mjs", ".cjs"}:
                 content_type = "application/javascript; charset=utf-8"
             return self._send_inline_bytes(data, content_type)
         if path == "/api/health":
@@ -43307,8 +44607,8 @@ class CodeAdminHandler(BaseHTTPRequestHandler):
         if path == "/assets/code-admin.js":
             return self._send_text(self.app.web_ui_code_admin_js(), "application/javascript; charset=utf-8")
         if path.startswith("/assets/js_lib/"):
-            filename = path.rsplit("/", 1)[-1]
-            fp = self.app.rag_js_lib_asset_path(filename)
+            asset_ref = path[len("/assets/js_lib/"):]
+            fp = self.app.rag_js_lib_asset_path(asset_ref)
             if not fp:
                 return self._send_json({"error": "asset not found"}, status=404)
             try:
@@ -43316,7 +44616,7 @@ class CodeAdminHandler(BaseHTTPRequestHandler):
             except Exception as exc:
                 return self._send_json({"error": str(exc)}, status=500)
             content_type = guess_mime_from_name(fp.name, "application/javascript")
-            if fp.suffix.lower() == ".js":
+            if fp.suffix.lower() in {".js", ".mjs", ".cjs"}:
                 content_type = "application/javascript; charset=utf-8"
             return self._send_inline_bytes(data, content_type)
         if path == "/api/health":
@@ -43938,6 +45238,17 @@ def main():
         except Exception as exc:
             print(f"[web-agent] failed to apply --config: {exc}")
             sys.exit(2)
+    # JS lib download (default on; set download_js_lib: false in --config to disable)
+    _js_dl_enabled = extract_js_lib_download_setting(external_config)
+    if _js_dl_enabled is None:
+        _js_dl_enabled = True
+    if _js_dl_enabled:
+        try:
+            app.offline_js_summary = ensure_offline_js_libs(
+                app.workspace, force=False, verbose=True, no_connection_deadline=60.0
+            )
+        except Exception as _js_exc:
+            print(f"[js_lib] download error: {_js_exc}")
     web_ui_state = app.configure_web_ui(
         config_path=str(web_ui_config_path),
         ui_dir=resolved_web_ui_dir,