nexforge-cli 0.2.15__tar.gz → 0.2.17__tar.gz

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: nexforge-cli
-Version: 0.2.15
+Version: 0.2.17
 Summary: NexForgeCLI — 一个面向 DeepSeek V4 的终端智能体(TUI + CLI 双模式)
 Project-URL: Homepage, https://gitee.com/Lighthorn/nexforgecli
 Author: NexForge
@@ -51,7 +51,7 @@ Description-Content-Type: text/markdown
 
 NexForgeCLI 是一个运行在终端里的智能体助手，既支持 DeepSeek/千问等多模型，也是**插件宿主**（plugins 目录即插即用）。既能作为全屏 TUI 交互式对话/编码，也能作为 one-shot 命令行工具嵌进脚本和管道。
 
-> 当前版本:**v0.2.15** · PyPI: `pip install nexforge-cli`
+> 当前版本:**v0.2.17** · PyPI: `pip install nexforge-cli`
 
 ---
 

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/README.md

@@ -8,7 +8,7 @@
 
 NexForgeCLI 是一个运行在终端里的智能体助手，既支持 DeepSeek/千问等多模型，也是**插件宿主**（plugins 目录即插即用）。既能作为全屏 TUI 交互式对话/编码，也能作为 one-shot 命令行工具嵌进脚本和管道。
 
-> 当前版本:**v0.2.15** · PyPI: `pip install nexforge-cli`
+> 当前版本:**v0.2.17** · PyPI: `pip install nexforge-cli`
 
 ---
 

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/manual/01-/345/256/211/350/243/205/344/270/216/351/205/215/347/275/256.md

@@ -1,6 +1,6 @@
 # 安装与配置
 
-> NexForgeCLI v0.2.15
+> NexForgeCLI v0.2.17
 
 ## 环境要求
 

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/manual/03-/346/250/241/345/236/213/351/205/215/347/275/256.md

@@ -4,7 +4,7 @@ NexForgeCLI 支持多模型：
 
 | 模型 | 支持方式 | 说明 |
 |------|----------|------|
-| **DeepSeek V4** | 内置 | flash/pro 双档位 + auto 自动路由，无需额外配置 |
+| **DeepSeek V4** | 内置(models.toml 可扩展) | flash/pro/auto 档位开箱可用；也可在 models.toml 挂独立模型(如实验版) |
 | **千问(qianwen)** | 专用底座 | 思考链流式显示 / enable_thinking 开关 / 多模态贴图直发(与 DeepSeek 平级) |
 | **OpenAI 兼容** | models.toml | Kimi/GPT/通义千问/智谱等一切 OpenAI 兼容接口 |
 | **Anthropic** | models.toml | Claude 系列(需安装额外依赖) |
@@ -34,6 +34,19 @@ auto 模式下的升级触发条件：
 - 默认开启，实时显示 AI 的推理过程(可折叠面板)
 - `/think off` 关闭思考(速度更快、费用更低)
 
+**挂独立模型**：DeepSeek 的 flash/pro 是内置档位，若想使用内置档位之外的模型(如限时实验版 `deepseek-v4.1-flash-expires-on-0910`)，可在 `~/.nexforge/models.toml` 加一个 `type = "deepseek"` 的 provider：
+
+```toml
+[[provider]]
+name = "deepseek-exp"
+type = "deepseek"
+base_url = "https://api.deepseek.com"
+models = ["deepseek-v4.1-flash-expires-on-0910"]
+default_model = "deepseek-v4.1-flash-expires-on-0910"
+```
+
+provider 的模型解析优先级：显式 `/model <名>` > `default_model` > `models` 第一个 > 内置 flash/pro。未配置 api_key 时自动回退全局 Key(`auth.toml`)。重启后在 F6 侧边栏点选即可切换。
+
 ## 千问（qianwen 专用底座）
 
 千问AI平台(platform.qianwenai.com / 阿里云百炼)有专用 provider，深度匹配千问特性：
@@ -96,6 +109,10 @@ models = ["claude-sonnet-4-20250514"]
 - `api_key` 和 `api_key_env` 都未配置 → 回退到全局保存的 Key（`~/.nexforge/auth.toml`）
 - `models`：可用模型 ID 列表
 - `default_model`：可选，指定默认模型，不填取 models 第一个
+- `multimodal`：可选（默认 `false`）。该 provider 挂载的模型**原生支持图片输入**时设为 `true`：
+  用户贴图会直接发给模型（更快、更准，且可保留思考模式），而非降级走识图工具。
+  适用于名字不含 "vision" 但实际能读图的模型（如 `deepseek-v4.1` 系列）。
+  内置 vision 档位无需设置（按模型名自动识别）；声明只对该 provider 列出的模型生效。
 
 软件只读不写此文件，不用担心 Key 被覆盖。
 

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/manual/05-/346/225/260/346/215/256/344/270/216/346/220/234/347/264/242.md

@@ -54,6 +54,12 @@ HTTP GET 抓取指定 URL，返回正文（截断至 20000 字符）。带浏览
 - `mode=auto`（默认）：优先用当前对话 provider 的视觉模型（如 deepseek-vision，共用对话 key），失败回退阿里云千问 qwen-vl
 - `mode=cross`：**双模型交叉验证**——deepseek-vision 与 qwen-vl 并行识别同一张图，返回双答案供交叉印证，减少单一模型的视觉误差（适合 GUI 验收/关键判断）
 
+**何时直接贴图、何时用本工具**（两条通道互补，不是二选一）：
+- **用户贴图**（剪贴板截图 / 拖入）→ 当前模型原生多模态时（vision 档位 / 千问 / `models.toml` 里声明 `multimodal = true` 的模型），图片直接发给模型理解，更快更准且可保留思考模式，此时不需要本工具；
+- **AI 自己产出的图片**（`window_screenshot` / `web_screenshot` 等截图工具落盘后）→ **必须用本工具**：
+  AI 不能把本地文件"贴"进对话，本工具是它读取本地图片的唯一通道，GUI 验收闭环依赖这一点；
+- 当前模型**不支持**图片输入时（如纯文本 flash/pro），用户贴图也会自动降级走本工具。
+
 ### image_gen（图片生成）
 
 提供文字描述，调用阿里云通义万相生成图片并保存到本地。

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/manual/08-/350/207/252/345/256/232/344/271/211/351/205/215/347/275/256.md

@@ -125,3 +125,7 @@ engine = "bing"              # bing | duckduckgo | google | searxng
 AI 收到系统提示后会优先查阅地图来快速定位代码，而不是反复 list_dir/search_content 全量扫描。
 
 每轮对话结束自动同步地图。
+
+**大项目友好**：地图扫描自动跳过 `node_modules`/`.git`/`.venv`/`dist`/`build` 等噪音目录(整棵子树不下钻)，
+且生成与同步都在**后台线程**执行——面对超大工程(如前端 monorepo 的数十万文件)也不会卡住启动界面。
+待分析代码超过 2000 个文件时按路径排序截断，保证界面快速可用。

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/manual/README.md

@@ -1,4 +1,4 @@
-# NexForgeCLI 用户手册 · v0.2.15
+# NexForgeCLI 用户手册 · v0.2.17
 
 ## 这是什么
 

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nexforge-cli"
-version = "0.2.15"
+version = "0.2.17"
 description = "NexForgeCLI — 一个面向 DeepSeek V4 的终端智能体(TUI + CLI 双模式)"
 readme = "README.md"
 requires-python = ">=3.11"

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/__init__.py

@@ -3,5 +3,5 @@
 TUI(全屏交互)+ CLI(one-shot / 管道)双模式。
 """
 
-__version__ = "0.2.15"
+__version__ = "0.2.17"
 __all__ = ["__version__"]

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/config.py

@@ -51,6 +51,10 @@ class ProviderDef(BaseModel):
     api_key: str | None = None
     models: list[str] = []                         # 可用模型 ID 列表
     default_model: str = ""                        # 默认模型,为空则取 models[0]
+    # 该 provider 挂的模型是否支持图片输入(原生多模态)。
+    # 用于名字不含 "vision" 但实际支持读图的模型(如 deepseek-v4.1 系列),
+    # 显式声明后: 用户贴图直达模型(展开为 image_url), 无需走识图工具。
+    multimodal: bool = False
     pricing: dict[str, PricingTier] = {}           # model_id → PricingTier
     timeout: float = 120.0
     max_retries: int = 2

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/core/goal_manager.py

@@ -9,6 +9,13 @@ from datetime import datetime, timezone
 
 DEFAULT_MAX_ROUNDS = 100
 
+# 目标/计划注入总监与开发者上下文的截断上限(字符)。
+# 目标必须完整传递: 长目标下截断会丢失后半部分(任务边界/次要目标/灵活处理等),
+# 导致总监/开发者做出错误判断(历史 bug: [:200]/[:300] 截断致目标信息丢失)。
+# 计划是中间产物(总监会重新生成), 可适当截断以控制 token。
+GOAL_CTX_LIMIT = 4000
+PLAN_CTX_LIMIT = 2000
+
 DIRECTOR_PROMPT = """[总监模式]
 你是项目总监,负责对整个开发周期做全局把控、目标分解和质量评审。
 

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/core/knowledge_base.py

@@ -105,8 +105,12 @@ class KnowledgeBase:
             try:
                 st = f.stat()
                 rel = f.relative_to(d).as_posix()
+                # 只读文件头(取标题用), 避免大 md 全量读入:
+                # read_text()[:N] 是"先全读再切片", 此处按字符读前 N 个
+                with f.open("r", encoding="utf-8", errors="replace") as fh:
+                    head = fh.read(4000)
                 result[rel] = {
-                    "title": self._title_of(f.read_text(encoding="utf-8")[:4000]),
+                    "title": self._title_of(head),
                     "size": st.st_size,
                     "mtime": st.st_mtime,
                 }

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/core/project_mapper.py

@@ -24,6 +24,7 @@ from __future__ import annotations
 import ast
 import hashlib
 import json
+import os
 from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
@@ -49,6 +50,33 @@ _EXCLUDED_DIRS: set[str] = {
 
 _EXCLUDED_PATTERNS: set[str] = {"test_", "_test", "conftest"}
 
+# 单次分析的文件数上限: 超大项目(数千模块)AST 解析会拖慢启动,
+# 按路径排序截断并在地图中注明, 保证 UI 快速可用。
+_MAX_FILES = 2000
+
+
+def _iter_files_pruned(base: Path, suffix: str = "") -> list[Path]:
+    """剪枝遍历: 排除目录直接不下钻(替代 Path.rglob)。
+
+    rglob 的目录过滤发生在遍历**之后**——它必须先走完每个子目录
+    (包括 node_modules/.git/.venv 这类噪音目录)才能产出结果。
+    超大前端项目 node_modules 可达数十万文件, Windows 上单次遍历
+    耗时数分钟(实测某项目 rglob 超 120s, 剪枝 0.17s), 而该遍历原本
+    同步发生在启动的 on_mount 里, 直接冻结 UI → 表现为"卡在启动黑屏"。
+
+    改用 os.walk(topdown=True) 原地改写 dirnames 剪枝, 排除目录的
+    子树完全不进入, 成本只与真实需分析的文件数相关。
+    """
+    out: list[Path] = []
+    for dirpath, dirnames, filenames in os.walk(base, topdown=True):
+        # 原地剪枝: 排除目录不再下降(必须在遍历 filenames 前改写)
+        dirnames[:] = [d for d in dirnames if d not in _EXCLUDED_DIRS]
+        for fn in filenames:
+            if suffix and not fn.endswith(suffix):
+                continue
+            out.append(Path(dirpath) / fn)
+    return out
+
 
 def _file_hash(path: Path) -> str | None:
     """快速文件指纹: mtime+size(仅 stat, 不读字节)。
@@ -215,15 +243,14 @@ class ProjectMapper:
         if not src.is_dir():
             src = self.root
         files: list[Path] = []
-        for f in sorted(src.rglob("*.py")):
-            if any(part in _EXCLUDED_DIRS for part in f.parts):
-                continue
+        # 剪枝遍历(排除目录不下钻), 替代原 rglob——见 _iter_files_pruned 说明
+        for f in sorted(_iter_files_pruned(src, ".py")):
             if any(p in f.name for p in _EXCLUDED_PATTERNS):
                 continue
             if f.name.startswith("_") and f.name not in ("__init__.py", "__main__.py"):
                 continue
             files.append(f)
-        return files
+        return files[:_MAX_FILES]
 
     def _analyze_all(self) -> list[_Analyzer]:
         files = self._walk()
@@ -269,7 +296,13 @@ class ProjectMapper:
                    if fp in old_f and old_f[fp] != h]
         added = [fp for fp in now_f if fp not in old_f]
         removed = [fp for fp in old_f if fp not in now_f]
-        return {"in_sync": not changed and not added and not removed,
+        in_sync = not changed and not added and not removed
+        # 边界: 地图输出被删除(.nexforge/map/ 或 map.md 没了)而哈希缓存还在时,
+        # 只比哈希会误判"已同步"→ 永不重建, AI 从此看不到地图。
+        # 故代码未变但输出缺失时, 也视为需要重建。
+        if in_sync and not self.index_content():
+            in_sync = False
+        return {"in_sync": in_sync,
                 "changed": changed, "added": added, "removed": removed,
                 "n_files": now["n_files"], "generated_at": old.get("generated_at", "(无)")}
 
@@ -474,9 +507,7 @@ class ProjectMapper:
                 continue
             lines.append(f"## {d}/")
             found = False
-            for md in sorted(base.rglob("*.md")):
-                if any(part in _EXCLUDED_DIRS for part in md.parts):
-                    continue
+            for md in sorted(_iter_files_pruned(base, ".md")):
                 rel = md.relative_to(self.root).as_posix()
                 size_kb = max(1, md.stat().st_size // 1024)
                 heads = self._extract_headings(md, max_heads=6)

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/core/provider.py

@@ -36,6 +36,23 @@ class BaseProvider(ABC):
         """
         return self.supports_multimodal
 
+    def _pdef_declares_multimodal(self, model: str) -> bool:
+        """models.toml 显式声明的多模态是否适用于该模型。
+
+        语义: ``pdef.multimodal = true`` 声明的是"**该 provider 挂载的**
+        模型支持图片输入"。若传入的模型名不在该 provider 的 models/
+        default_model 列表里(例如同一个 provider 实例被要求跑别的模型),
+        声明不适用, 交由调用方的名字启发式判断——否则会把纯文本模型
+        也误判为多模态, 导致贴图发给看不懂图的模型。
+        """
+        p = getattr(self, "pdef", None)
+        if p is None or not getattr(p, "multimodal", False):
+            return False
+        declared = [x.lower() for x in (getattr(p, "models", None) or [])]
+        if getattr(p, "default_model", ""):
+            declared.append(p.default_model.lower())
+        return (not declared) or (model.lower() in declared)
+
     async def list_models(self) -> list[str]:
         """拉取当前 API key 下可用的模型 ID 列表。
 

nexforge_cli-0.2.17/src/nexforge/features/map_feature.py

@@ -0,0 +1,91 @@
+"""项目地图特性——每轮结束自动同步 + 注入地图提示。"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from nexforge.core.project_mapper import ProjectMapper
+from nexforge.core.system_inject import MAP_MARKER, inject_system
+from nexforge.i18n import t
+
+if TYPE_CHECKING:
+    from nexforge.ui.screens.chat import ChatScreen
+
+
+_MAP_MARKER = MAP_MARKER  # 区分旧 [项目地图] 单文件格式,避免旧会话去重误判
+_MAP_PROMPT = (
+    f"{_MAP_MARKER} 项目结构分析存于 .nexforge/map/ 目录(分层索引体系)。\n"
+    "总索引见下方(已注入本会话): 各层模块清单 + 详细文件导航。\n"
+    "定位函数/追踪调用/查依赖/查文档时:\n"
+    "1. 先看总索引判断属于哪一层/哪个文件\n"
+    "2. 再 read_file 读对应详细文件(.nexforge/map/symbols-<层>.md 等)\n"
+    "3. 避免大范围 list_dir/search_content 扫描全项目。"
+)
+
+
+class MapFeature:
+    name = "map"
+
+    def register(self, screen: ChatScreen) -> None:
+        self.screen = screen
+        from nexforge.core.context import get_project_root
+        self._mapper = ProjectMapper(get_project_root())
+        self._syncing = False  # 防重入: 后台同步进行中不重复触发
+
+    def on_mount(self) -> None:
+        """首次启动自动生成地图,并注入总索引到会话(先传索引, AI 按需读详细文件)。
+
+        关键: sync() 必须走后台线程。它要遍历项目树 + AST 解析全部模块,
+        超大项目(如前端工程 node_modules 数十万文件)同步执行会冻结事件循环,
+        表现为"卡在启动黑屏"(实测某项目单次遍历 >120s)。
+        故先用已有地图注入(保证 AI 立即可用), 同步完成后再刷新注入。
+        """
+        s = self.screen
+        self._inject_index()
+        s._spawn(self._sync_and_inject())
+
+    def _inject_index(self) -> None:
+        """注入当前地图总索引(inject_system 按 marker 去重, 重复调用即替换)。"""
+        s = self.screen
+        idx = self._mapper.index_content()
+        content = _MAP_PROMPT if not idx else _MAP_MARKER + "\n" + idx
+        inject_system(s.session.messages, content, _MAP_MARKER)
+
+    async def _sync_and_inject(self) -> None:
+        """后台线程同步地图, 完成后回主线程刷新注入与提示。"""
+        import asyncio
+        if self._syncing:
+            return  # 已有同步在跑(避免并发写地图文件)
+        self._syncing = True
+        try:
+            await asyncio.to_thread(self._mapper.sync)
+        except Exception:
+            return  # 地图同步失败不影响主流程
+        finally:
+            self._syncing = False
+        self._inject_index()
+        self.screen._note(t("note.map_generated"), scroll=True)
+
+    def on_turn_done(self, content: str) -> None:
+        """每轮结束快速哈希比对,有变化则自动同步(后台线程, 不阻塞回合)。"""
+        if self._syncing:
+            return  # 上一轮同步未完成, 跳过本轮(变更下轮再比对)
+        self._syncing = True
+        self.screen._spawn(self._check_and_sync())
+
+    async def _check_and_sync(self) -> None:
+        import asyncio
+        try:
+            report = await asyncio.to_thread(self._mapper.check)
+            if report["in_sync"]:
+                return
+            n = len(report["changed"]) + len(report["added"]) + len(report["removed"])
+            await asyncio.to_thread(self._mapper.sync)
+            self.screen._note(t("note.map_autosynced", n=str(n)), scroll=True)
+        except Exception:
+            pass  # 自动同步失败不影响主流程
+        finally:
+            self._syncing = False
+
+    def bindings(self) -> list[tuple[str, str, str]]:
+        return []

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/features/mode_features.py

@@ -9,6 +9,7 @@ from nexforge.features.base import Feature
 from nexforge.config import save_config
 from nexforge.i18n import t
 from nexforge.core.context import get_project_root
+from nexforge.core.goal_manager import GOAL_CTX_LIMIT, PLAN_CTX_LIMIT
 from nexforge.core.memory_engine import MemoryEngine, _MARKER_OPS, _MARKER_GOAL, clear_messages_by_marker, has_marker
 
 if TYPE_CHECKING:
@@ -106,6 +107,7 @@ class GoalModeFeature:
         if gm.rounds_dir.exists():
             shutil.rmtree(gm.rounds_dir, ignore_errors=True)
         gm.rounds_dir.mkdir(parents=True, exist_ok=True)
+        self._stop_director = False  # 复位停止标志, 防残留导致恢复的循环立即退出
         self._turn_count = 1
         # 清理残留状态(防上次崩溃遗留 dev_done_flag 导致重复验收)
         self._dev_done_flag = False
@@ -246,14 +248,19 @@ class GoalModeFeature:
         from nexforge.core.goal_manager import GoalManager
         gm = GoalManager(get_project_root())
         goal = gm.read_goal()
-        gm.set_goal(goal + "\n\n[用户补充意见]\n" + feedback[:500])
+        gm.set_goal(goal + "\n\n[用户补充意见]\n" + feedback[:2000])
         self._awaiting_plan_confirm = False
         self._turn_count = 0  # 让重新规划回复再次作为 turn=1(方案轮)
         s._note(t("note.goal_plan_amended"), scroll=True)
+        # 修复: 用户反馈必须完整传给总监, 不能依赖 read_goal()[:300] 截断。
+        # 旧实现把反馈追加到 goal 文件末尾后, 仅取前 300 字符作为 prompt,
+        # 而反馈永远位于 300 字符之后 → 总监收不到修改意见
+        # (表现为"传输截断/未检测到新的修改意见正文")。
         s._run_agent(
             "[项目总监] 用户对初步方案提出了修改意见, 请结合意见重新规划方案。"
             "注意: 先输出规划方案, 不要发布执行指令, 等待用户确认后再动工。\n"
-            "目标:" + gm.read_goal()[:300]
+            "【原始目标】\n" + goal +
+            "\n\n【用户本次修改意见】\n" + feedback[:2000]
         )
 
     def _fed_members_prompt(self) -> str:
@@ -348,8 +355,8 @@ class GoalModeFeature:
         from nexforge.core.goal_manager import GoalManager
         s = self.screen
         gm = GoalManager(get_project_root())
-        goal = gm.read_goal()[:300]
-        plan = gm.read_plan()[:300]
+        goal = gm.read_goal()[:GOAL_CTX_LIMIT]
+        plan = gm.read_plan()[:PLAN_CTX_LIMIT]
         fed_members = self._fed_members_prompt()  # 联结体成员(跨项目编排)
         ctx = (
             "[项目总监] 首次目标分解。\n"
@@ -387,13 +394,13 @@ class GoalModeFeature:
         max_r = s.config.ui.max_rounds
         cycle_n = self._turn_count - 1
         report = (report or self._dev_report)[:2000]
-        goal = gm.read_goal()[:300]
-        plan = gm.read_plan()[:300]
+        goal = gm.read_goal()[:GOAL_CTX_LIMIT]
+        plan = gm.read_plan()[:PLAN_CTX_LIMIT]
         fed_members = self._fed_members_prompt()
         ctx = (
             "[项目总监复盘] 第" + str(cycle_n) + "/" + str(max_r) + "轮。\n"
             "目标:" + goal + "\n"
-            "计划:" + plan[:500] + "\n"
+            "计划:" + plan + "\n"
             "开发者报告:" + report + "\n\n"
             "请按审核框架复盘:\n"
             "1. 本轮完成了多少?(核心/重要/次要)\n"
@@ -435,7 +442,7 @@ class GoalModeFeature:
         from nexforge.core.goal_manager import GoalManager
         s = self.screen
         gm = GoalManager(get_project_root())
-        goal = gm.read_goal()[:300]
+        goal = gm.read_goal()[:GOAL_CTX_LIMIT]
         dev_status = "开发者正在执行中" if self._dev_busy else "开发者空闲, 等待下一任务"
         ctx = (
             "[项目总监] 用户在工作进行中与你沟通(下栏沟通区)。\n"
@@ -461,15 +468,15 @@ class GoalModeFeature:
         s = self.screen
         gm = GoalManager(get_project_root())
         max_r = s.config.ui.max_rounds
-        goal = gm.read_goal()[:300]
-        plan = gm.read_plan()[:300]
+        goal = gm.read_goal()[:GOAL_CTX_LIMIT]
+        plan = gm.read_plan()[:PLAN_CTX_LIMIT]
         s.call_later(s._mount, DirectorNote(
             t("note.dev_round", n=str(round_n), mx=str(max_r))
         ), dev=True)
         msg = (
             "[开发者] 第" + str(round_n) + "/" + str(max_r) + "轮。\n"
             "目标:" + goal + "\n"
-            "计划:" + plan[:500] + "\n"
+            "计划:" + plan + "\n"
             "总监指令:" + instruction[:2000] + "\n\n"
             "请按指令执行。完成后提交执行报告。"
             "若遇到不可逾越的障碍,在报告开头标注 [BLOCKED]。"
@@ -502,6 +509,35 @@ class GoalModeFeature:
             self._resume_director_loop()
         self._wake_event.set()
 
+    def reset_for_session_change(self) -> None:
+        """会话切换/新建时完整重置目标模式运行状态(不关闭 goal_mode 开关)。
+
+        目标文件(goal/plan/rounds)是项目级跨会话共享,但总监循环是内存态。
+        切换会话时旧循环被 cancel, 若运行状态(_turn_count/_dev_done_flag/
+        _stop_director 等)残留, 新会话输入会走错分支:
+        - _turn_count 残留 → 方案生成后 on_turn_done 跳过 turn=1 分支,
+          方案不落盘、不进入待确认, 总监循环无法启动
+        - 旧目标文件残留 → 新会话输入被误判为"旧目标插话"入队, 循环又没恢复
+        结果都表现为"AI 回复一段就停, 必须反复输入才能继续"。
+        这里清零运行状态 + 清理目标文件, 让切换后输入作为全新目标进入正常流程。
+        """
+        self._stop_director = False  # 关键: 复位停止标志, 否则恢复的循环立即退出
+        self._awaiting_plan_confirm = False
+        self._director_busy = False
+        self._turn_count = 0  # 关键: 复位轮次, 否则方案生成后 on_turn_done 走错分支
+        self._user_inbox.clear()
+        self._dev_busy = False
+        self._dev_done_flag = False
+        self._dev_report = ""
+        self._director_loop_task = None
+        self._wake_event.clear()
+        # 清理目标文件, 防旧目标残留被误判为插话
+        try:
+            from nexforge.core.goal_manager import GoalManager
+            GoalManager(get_project_root()).cleanup()
+        except Exception:
+            pass
+
     def _stop_director_loop(self) -> None:
         """停止总监循环。"""
         self._stop_director = True

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/features/session_feature.py

@@ -109,7 +109,17 @@ class SessionFeature:
         s._director_session_id = ""
         s.session = Session()
         s.session.messages = list(msgs)
-        if not msgs or msgs[0].get("role") != "system":
+        # 系统提示判断: 摘要 system 消息(历史压缩)不算完整系统提示,
+        # 必须注入 DEFAULT_SYSTEM(否则 AI 缺失行为规范, 只回复一段就停)。
+        # 与 _auto_resume 保持一致 —— 原判断只看首条 role, 而压缩过的会话
+        # 首条是 "[历史摘要" system 消息(save_session 只回显摘要 system),
+        # 会误判为已有 system 而漏注入 DEFAULT_SYSTEM。
+        has_full_sys = any(
+            m.get("role") == "system"
+            and str(m.get("content", "")).startswith("【推理要求】")
+            for m in s.session.messages
+        )
+        if not has_full_sys:
             s.session.messages.insert(0, {"role": "system", "content": DEFAULT_SYSTEM})
         s._session_id = info.id
         s._session_name = info.name
@@ -145,11 +155,20 @@ class SessionFeature:
     # ---- 自动保存 ----
 
     def _reset_goal_confirm(self) -> None:
-        """切换/新建会话时重置目标模式方案确认状态(防残留误路由)。"""
+        """切换/新建会话时完整重置目标模式运行状态(防残留误路由)。
+
+        修复: 之前只重置 _awaiting_plan_confirm, 而 _turn_count/_dev_done_flag/
+        _stop_director 等运行状态与旧目标文件(项目级)残留, 导致切换会话后
+        总监循环无法正确恢复, 表现为"AI 回复一段就停, 必须反复输入才能继续"。
+        """
         try:
             gf = next((f for f in self.screen._features._features
                        if getattr(f, 'name', '') == 'goal_mode'), None)
-            if gf is not None:
+            if gf is None:
+                return
+            if hasattr(gf, 'reset_for_session_change'):
+                gf.reset_for_session_change()
+            else:
                 gf._awaiting_plan_confirm = False
         except Exception:
             pass

{nexforge_cli-0.2.15 → nexforge_cli-0.2.17}/src/nexforge/provider/deepseek.py

@@ -50,6 +50,7 @@ class DeepSeekProvider(BaseProvider):
         api_key: str | None = None,
     ):
         self.config = config
+        self.pdef = pdef
         key = api_key or config.resolve_api_key()
         if not key:
             raise ProviderError(
@@ -68,6 +69,7 @@ class DeepSeekProvider(BaseProvider):
         """用明确 key 创建 Provider(跳过 resolve_api_key 链)。"""
         inst = cls.__new__(cls)
         inst.config = config
+        inst.pdef = None
         inst._client = AsyncOpenAI(
             api_key=api_key,
             base_url=config.provider.base_url,
@@ -81,17 +83,45 @@ class DeepSeekProvider(BaseProvider):
 
     # ── 多模态(视觉模型) ────────────────────────────────────
 
+    def _resolve_model(self, tier: Tier | None, model: str | None = None) -> str:
+        """解析实际使用的模型名。
+
+        优先级: 显式传入 model > pdef.default_model > pdef.models[0] > 内置 tier 映射。
+        支持 models.toml 里以 type="deepseek" 注册独立模型(如实验版 flash 变体),
+        不再被内置 config.models.flash/pro 写死。
+        """
+        if model:
+            return model
+        if self.pdef and self.pdef.default_model:
+            return self.pdef.default_model
+        if self.pdef and self.pdef.models:
+            return self.pdef.models[0]
+        return self.config.model_id(tier)
+
     @property
     def current_model(self) -> str:
         """当前使用的模型名(最近一次调用或默认档位)。"""
         if getattr(self, "_last_model", ""):
             return self._last_model
-        return self.config.model_id(self.config.models.default_tier)
+        return self._resolve_model(self.config.models.default_tier)
 
     def supports_model_multimodal(self, model: str = "") -> bool:
-        """视觉模型(模型名含 vision)支持图片输入。"""
+        """该模型是否支持图片输入(原生多模态)。
+
+        判定顺序:
+        1. 模型名含 "vision" → 支持(内置 vision 档位, 如 deepseek-v4-flash-vision-exp);
+        2. models.toml 里该 provider 显式声明 ``multimodal = true`` → 支持。
+           用于名字不含 vision 但实际能读图的模型(如 deepseek-v4.1 系列,
+           实测: 对已知内容的图能准确回答圆/三角颜色与文字, 且不编造图中没有的元素);
+        3. 否则不支持——纯文本模型(如 deepseek-v4-flash)收到图片会返回空。
+
+        判为支持后, 用户贴图走 ``[图片附件: 路径]`` 通道直发达模型;
+        判为不支持则降级走识图工具(image_vision)。
+        """
         m = (model or self.current_model).lower()
-        return "vision" in m
+        if "vision" in m:
+            return True
+        return self._pdef_declares_multimodal(m)
 
     def _expand_image_attachments(
         self, messages: list[dict], model: str | None
@@ -157,6 +187,7 @@ class DeepSeekProvider(BaseProvider):
         tier: Tier | None,
         thinking: bool | None,
         effort: Effort | None,
+        model: str | None = None,
     ) -> dict:
         cfg = self.config
         think = cfg.models.thinking if thinking is None else thinking
@@ -169,7 +200,7 @@ class DeepSeekProvider(BaseProvider):
             extra_body["reasoning_effort"] = eff
 
         kwargs: dict[str, Any] = {
-            "model": cfg.model_id(tier),
+            "model": self._resolve_model(tier, model),
             "messages": messages,
             "stream": True,
             "stream_options": {"include_usage": True},
@@ -215,14 +246,14 @@ class DeepSeekProvider(BaseProvider):
         thinking: bool | None = kwargs.get("thinking")
         effort: Effort | None = kwargs.get("effort")
         resolved_tier: Tier = tier or self.config.models.default_tier
-        model_id = model or self.config.model_id(tier)
+        model_id = self._resolve_model(tier, model)
         self._last_model = model_id  # 供 current_model / 多模态判断
         # 视觉模型: 强制 thinking off(exp 模型未确认支持思考模式, 避免 400)
         if "vision" in model_id.lower() and thinking is not False:
             thinking = False
         # 多模态: 把 [图片附件: 路径] 展开为 base64 image_url
         messages = self._expand_image_attachments(messages, model_id)
-        bkwargs = self._build_kwargs(messages, tools, tier, thinking, effort)
+        bkwargs = self._build_kwargs(messages, tools, tier, thinking, effort, model_id)
 
         content = ""
         reasoning = ""