codebee 0.1.39 → 0.1.41

package/CHANGELOG.md

@@ -6,6 +6,23 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.41（2026-09-22）
+
+### 🛠 问题修复
+
+- 断点续跑/重跑更省钱：同一任务再次生成大纲或执行计划时直接命中上次结果的精确缓存（1 小时内有效），不再重复花一次全量规划调用；大纲首试成功但格式不合规时的重试仍会重新生成（保「换一次样本」语义，不会拿同一份坏文本空转）。
+
+## v0.1.40（2026-09-21）
+
+### 🛠 问题修复
+
+- 「厂商/模型」选择器两步手选修复：点厂商只展开该厂商模型列表（不再自动带推荐，模型必须亲手点）；修复点厂商后菜单瞬间被收起、模型永远选不上的问题（真机定位：菜单重写 DOM 与「点外面收起」监听的竞态）；菜单改为向上弹出，不再被右侧栏遮挡。
+
+### ✨ 新功能
+
+- 对话输入条与新建任务同款三件套：编排模式 / 思考程度 / 厂商模型选择器直接嵌在输入条工具行，改动即写入任务参数（下一轮对话生效）；打开任务时自动回填当前值。
+- 对话输入条的待发图片以缩略图展示（不再只是一串文件名），移除按钮悬浮右上角；气泡内图片缩略图不再压住输入框边框。
+
 ## v0.1.39（2026-09-21）
 
 ### 🛠 问题修复

package/README.md

@@ -23,6 +23,9 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 <!-- relnotes:start -->
 ### 🛠 问题修复 · Fixes
 
+- 断点续跑/重跑更省钱：同任务再次生成大纲或计划直接命中精确缓存（1 小时内），不重复花全量规划调用；格式不合规的重试仍重新生成。
+- Resuming or re-running a task now hits an exact cache for outline/plan regeneration (within 1 hour), skipping a full planning call; format-failure retries still regenerate.
+
 - 修复长任务上下文撑爆后重试仍失败：压缩摘要此前只写日志、没真正替换发往模型的上下文；现在重试用「压缩摘要+最近消息」重建请求并放弃膨胀的旧会话，超长任务能真正续跑。
 - Fixed long-task overflow retries failing again: compaction summaries used to go only to logs. Retries now rebuild the request from the summary plus recent messages and drop the bloated old session.
 

package/app/core/planner.py

@@ -114,13 +114,13 @@ def _log_usage(source, role, task, res, agent=None, tool="", model="", provider=
     except Exception:
         pass
 
-CODE_PLAN_PROMPT = """你是技术负责人。请把下面的开发目标拆解为 __N__ 个以内、按顺序执行的子任务，
-并判定任务难度和后续质量步骤。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"difficulty": "easy 或 hard", "workflow": {"review_required": true, "max_repair_rounds": 0, "allow_switch": false}, "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令", "files": ["涉及的文件路径"]}]}
-难度判定：常规增删改查/小函数/格式调整 = easy；跨模块改动/架构调整/复杂算法/安全相关 = hard。
-质量步骤判定：涉及安全、数据迁移、并发、权限、公共 API 或跨模块改动时必须评审；
-有明确自动验收的低风险小改可不做模型评审。max_repair_rounds 取 0-2，只有复杂任务才建议换将。
-子任务粒度要可独立验证；最后一个子任务必须包含整体联调/收尾。
+CODE_PLAN_PROMPT = """你是技术负责人。请把下面的开发目标拆解为 __N__ 个以内、按顺序执行的子任务，
+并判定任务难度和后续质量步骤。只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
+{"difficulty": "easy 或 hard", "workflow": {"review_required": true, "max_repair_rounds": 0, "allow_switch": false}, "subtasks": [{"title": "简短标题", "detail": "具体要做什么，给执行工程师的直接指令", "files": ["涉及的文件路径"]}]}
+难度判定：常规增删改查/小函数/格式调整 = easy；跨模块改动/架构调整/复杂算法/安全相关 = hard。
+质量步骤判定：涉及安全、数据迁移、并发、权限、公共 API 或跨模块改动时必须评审；
+有明确自动验收的低风险小改可不做模型评审。max_repair_rounds 取 0-2，只有复杂任务才建议换将。
+子任务粒度要可独立验证；最后一个子任务必须包含整体联调/收尾。
 
 ## 先探索再计划（重要，借鉴 OpenSpec explore）
 拆解之前先用你的读文件/搜索工具**实际查看工作目录**，找到目标相关的真实文件与函数，再据此拆解。
@@ -137,12 +137,12 @@ __CONTEXT__
 ## 验收命令（最终必须通过）
 __VERIFY__"""
 
-REVIEW_OUTLINE_PROMPT = """你是内容主编。请为下面的创作任务拟一份写作大纲（要点列表，3-8 条），
-并按内容风险建议后续质量步骤。
-只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
-{"outline": ["要点1", "要点2", ...], "workflow": {"reviewers": 1, "review_rounds": 1}}
-reviewers 取 1-2，review_rounds 取 1-3；研究报告、技术方案、长文和高发布门槛应增加，
-普通邮件、短翻译、工作汇报等低风险短内容保持 1。
+REVIEW_OUTLINE_PROMPT = """你是内容主编。请为下面的创作任务拟一份写作大纲（要点列表，3-8 条），
+并按内容风险建议后续质量步骤。
+只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
+{"outline": ["要点1", "要点2", ...], "workflow": {"reviewers": 1, "review_rounds": 1}}
+reviewers 取 1-2，review_rounds 取 1-3；研究报告、技术方案、长文和高发布门槛应增加，
+普通邮件、短翻译、工作汇报等低风险短内容保持 1。
 
 ## 创作任务
 __GOAL__
@@ -327,9 +327,14 @@ def make_serial_outline(task, author_agent=None, workdir=None, ev=None, log_path
             # 否则 stop_reason=max_tokens、正文为空（实测 2048 全被思考吞掉）
             # 流式回调把增量实时写进步骤日志，直连生成不再是一行标题的黑箱
             cb = _log_streamer(log_path)
-            res = modelhub.chat(prov["id"], model, prompt,
-                                max_tokens=16000, timeout=300, on_delta=cb,
-                                reasoning_effort=_reasoning_effort(task))
+            # §07 T2.2 幂等精确缓存（TTL 1h）：断点续跑/重跑同任务时大纲
+            # prompt 逐字节相同，命中省一次全量规划调用。第 2 次尝试故意
+            # 旁路缓存——首试 ok 但 JSON 不合法时，重试要的是「再抽一次样
+            # 本」而不是同一份坏文本。
+            res = modelhub.chat(prov["id"], model, prompt,
+                                max_tokens=16000, timeout=300, on_delta=cb,
+                                reasoning_effort=_reasoning_effort(task),
+                                cache_ttl=3600 if _attempt == 1 else 0)
             cb.flush()
             _log_usage("outline", "outline", task, res, model=model,
                        provider=prov.get("name", prov.get("id", "")),
@@ -409,56 +414,56 @@ def _norm_subtasks(data):
     return steps or None
 
 
-def _plan_difficulty(data):
+def _plan_difficulty(data):
     d = str((data or {}).get("difficulty") or "").lower()
-    return d if d in ("easy", "hard") else None
-
-
-def _plan_workflow(data):
-    """规范化规划器给出的后续步骤建议；最终安全下限由任务编译器裁决。"""
-    raw = (data or {}).get("workflow")
-    if not isinstance(raw, dict):
-        return None
-    out = {}
-    if isinstance(raw.get("review_required"), bool):
-        out["review_required"] = raw["review_required"]
-    try:
-        if "max_repair_rounds" in raw:
-            out["max_repair_rounds"] = max(0, min(2, int(raw["max_repair_rounds"])))
-    except (TypeError, ValueError):
-        pass
-    if isinstance(raw.get("allow_switch"), bool):
-        out["allow_switch"] = raw["allow_switch"]
-    return out or None
-
-
-def _orchestrator():
-    """编排者可用时返回 (provider, model)，否则 None。"""
-    try:
-        return modelhub.resolve_orchestrator()
-    except Exception:
-        return None
-
-
-def _reasoning_effort(task):
-    """把任务级思考程度映射为直连编排者支持的 reasoning 参数。"""
-    task = task if isinstance(task, dict) else {}
-    selected = str(task.get("thinking") or "standard").strip().lower()
-    if selected in ("low", "standard", "high"):
-        return {"low": "low", "standard": "medium", "high": "high"}[selected]
-    mode = str(task.get("mode") or "auto").lower()
-    difficulty = str(task.get("difficulty") or "auto").lower()
-    ttype = str(task.get("type") or "").lower()
-    try:
-        threshold = float(task.get("threshold") or 7.0)
-    except (TypeError, ValueError):
-        threshold = 7.0
-    if mode == "fast" or difficulty == "easy" or threshold <= 6.0:
-        return "low"
-    if (mode == "expert" or difficulty == "hard" or threshold >= 8.5
-            or ttype in ("research", "tech_proposal", "serial_novel")):
-        return "high"
-    return "medium"
+    return d if d in ("easy", "hard") else None
+
+
+def _plan_workflow(data):
+    """规范化规划器给出的后续步骤建议；最终安全下限由任务编译器裁决。"""
+    raw = (data or {}).get("workflow")
+    if not isinstance(raw, dict):
+        return None
+    out = {}
+    if isinstance(raw.get("review_required"), bool):
+        out["review_required"] = raw["review_required"]
+    try:
+        if "max_repair_rounds" in raw:
+            out["max_repair_rounds"] = max(0, min(2, int(raw["max_repair_rounds"])))
+    except (TypeError, ValueError):
+        pass
+    if isinstance(raw.get("allow_switch"), bool):
+        out["allow_switch"] = raw["allow_switch"]
+    return out or None
+
+
+def _orchestrator():
+    """编排者可用时返回 (provider, model)，否则 None。"""
+    try:
+        return modelhub.resolve_orchestrator()
+    except Exception:
+        return None
+
+
+def _reasoning_effort(task):
+    """把任务级思考程度映射为直连编排者支持的 reasoning 参数。"""
+    task = task if isinstance(task, dict) else {}
+    selected = str(task.get("thinking") or "standard").strip().lower()
+    if selected in ("low", "standard", "high"):
+        return {"low": "low", "standard": "medium", "high": "high"}[selected]
+    mode = str(task.get("mode") or "auto").lower()
+    difficulty = str(task.get("difficulty") or "auto").lower()
+    ttype = str(task.get("type") or "").lower()
+    try:
+        threshold = float(task.get("threshold") or 7.0)
+    except (TypeError, ValueError):
+        threshold = 7.0
+    if mode == "fast" or difficulty == "easy" or threshold <= 6.0:
+        return "low"
+    if (mode == "expert" or difficulty == "hard" or threshold >= 8.5
+            or ttype in ("research", "tech_proposal", "serial_novel")):
+        return "high"
+    return "medium"
 
 
 def make_code_plan(task, planner_agent, workdir, ev=None, resume=None, log_path=None):
@@ -482,10 +487,10 @@ def make_code_plan(task, planner_agent, workdir, ev=None, resume=None, log_path=
     _log_usage("plan", "plan", task, res, agent=planner_agent)
     data = runner.extract_json(res.get("text") or "")
     steps = _norm_subtasks(data)
-    if steps:
-        return {"source": "llm(%s)" % planner_agent["id"], "steps": steps,
-                "difficulty": _plan_difficulty(data),
-                "workflow": _plan_workflow(data)}
+    if steps:
+        return {"source": "llm(%s)" % planner_agent["id"], "steps": steps,
+                "difficulty": _plan_difficulty(data),
+                "workflow": _plan_workflow(data)}
     return _fallback_code_plan(task, "LLM 计划解析失败，退化为单步模板")
 
 
@@ -496,13 +501,15 @@ def _fallback_code_plan(task, note):
 
 def _orch_code_plan(task, prov, model, log_path=None):
     cb = _log_streamer(log_path)
+    # §07 T2.2：代码计划同任务同 prompt（断点续跑/重试），TTL 1h 精确缓存
     res = modelhub.chat(prov["id"], model,
                         (CODE_PLAN_PROMPT.replace("__N__", str(MAX_SUBTASKS))
                          .replace("__GOAL__", task["goal"])
                          .replace("__CONTEXT__", task.get("context") or "（无）")
                          .replace("__VERIFY__", task.get("verify_command") or "（未配置）")),
-                        max_tokens=8000, timeout=300, on_delta=cb,
-                        reasoning_effort=_reasoning_effort(task))
+                        max_tokens=8000, timeout=300, on_delta=cb,
+                        reasoning_effort=_reasoning_effort(task),
+                        cache_ttl=3600)
     cb.flush()
     _log_usage("plan", "plan", task, res, model=model,
                provider=prov.get("name", prov.get("id", "")))
@@ -515,9 +522,9 @@ def _orch_code_plan(task, prov, model, log_path=None):
     if not steps:
         _append_log(log_path, "编排者计划返回内容无法解析为子任务，回退 CLI")
         return None
-    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
-            "steps": steps, "difficulty": _plan_difficulty(data),
-            "workflow": _plan_workflow(data)}
+    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
+            "steps": steps, "difficulty": _plan_difficulty(data),
+            "workflow": _plan_workflow(data)}
 
 
 def make_review_outline(task):
@@ -530,8 +537,9 @@ def make_review_outline(task):
                         (REVIEW_OUTLINE_PROMPT
                          .replace("__GOAL__", task["goal"])
                          .replace("__CONTEXT__", task.get("context") or "（无）")),
-                        max_tokens=8000, timeout=300,
-                        reasoning_effort=_reasoning_effort(task))
+                        max_tokens=8000, timeout=300,
+                        reasoning_effort=_reasoning_effort(task),
+                        cache_ttl=3600)   # §07 T2.2：同任务重试幂等，TTL 1h
     _log_usage("outline", "outline", task, res, model=model,
                provider=prov.get("name", prov.get("id", "")))
     if not res["ok"]:
@@ -541,20 +549,20 @@ def make_review_outline(task):
     if not isinstance(outline, list):
         return None
     items = [str(x).strip()[:120] for x in outline if str(x).strip()][:8]
-    if not items:
-        return None
-    workflow = data.get("workflow") if isinstance(data.get("workflow"), dict) else {}
-    try:
-        reviewers = max(1, min(2, int(workflow.get("reviewers") or 1)))
-    except (TypeError, ValueError):
-        reviewers = 1
-    try:
-        review_rounds = max(1, min(3, int(workflow.get("review_rounds") or 1)))
-    except (TypeError, ValueError):
-        review_rounds = 1
-    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
-            "items": items,
-            "workflow": {"reviewers": reviewers, "review_rounds": review_rounds}}
+    if not items:
+        return None
+    workflow = data.get("workflow") if isinstance(data.get("workflow"), dict) else {}
+    try:
+        reviewers = max(1, min(2, int(workflow.get("reviewers") or 1)))
+    except (TypeError, ValueError):
+        reviewers = 1
+    try:
+        review_rounds = max(1, min(3, int(workflow.get("review_rounds") or 1)))
+    except (TypeError, ValueError):
+        review_rounds = 1
+    return {"source": "编排者(%s · %s)" % (prov.get("name", prov["id"]), model),
+            "items": items,
+            "workflow": {"reviewers": reviewers, "review_rounds": review_rounds}}
 
 
 def make_novel_plan(task, author, critics):

package/app/core/store.py

@@ -104,12 +104,12 @@ def create_task(payload):
     if not wd.is_dir():
         raise ValueError("工作目录不存在: %s" % workdir)
     mode = payload.get("mode")
-    if mode not in ("auto", "fast", "expert", "manual"):
-        mode = "manual" if payload.get("implementer") else "auto"
+    if mode not in ("auto", "fast", "expert", "manual"):
+        mode = "manual" if payload.get("implementer") else "auto"
     difficulty = payload.get("difficulty")
     if difficulty not in ("auto", "easy", "hard", "default"):
         difficulty = "auto"
-    task = {
+    task = {
         "id": _new_id("t"), "type": flow["id"], "engine": flow["engine"],
         "title": title, "goal": goal,
         "context": _text(payload.get("context"), "context"),
@@ -119,16 +119,16 @@ def create_task(payload):
         "implementer": payload.get("implementer") or "",
         "attachments": [],
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "status": "created",
-    }
-    thinking = str(payload.get("thinking") or "standard").strip().lower()
-    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
-    if flow["engine"] == "direct":
-        task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
-                                            "direct_provider_id")[:80]
-        task["direct_model"] = _text(payload.get("direct_model"), "direct_model")[:160]
-        if task["direct_model"] and not task["direct_provider_id"]:
-            raise ValueError("指定对话模型时必须同时指定厂商")
+        "status": "created",
+    }
+    thinking = str(payload.get("thinking") or "standard").strip().lower()
+    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
+    if flow["engine"] == "direct":
+        task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
+                                            "direct_provider_id")[:80]
+        task["direct_model"] = _text(payload.get("direct_model"), "direct_model")[:160]
+        if task["direct_model"] and not task["direct_provider_id"]:
+            raise ValueError("指定对话模型时必须同时指定厂商")
     # 代码版本：仅当引用合法才固化（流水线执行前据此检出任务分支）
     from . import gitmod
     git_rev = _text(payload.get("git_rev"), "git_rev")
@@ -141,8 +141,8 @@ def create_task(payload):
         task["git_rev"] = git_rev
     if flow["engine"] == "code":
         task["verify_command"] = _text(payload.get("verify_command"), "verify_command")
-    elif flow["engine"] == "direct":
-        pass  # 直连任务：无验证命令也无评审参数，目标+附件即全部输入
+    elif flow["engine"] == "direct":
+        pass  # 直连任务：无验证命令也无评审参数，目标+附件即全部输入
     else:
         ms = _text(payload.get("manuscript") or flow.get("manuscript") or "manuscript.md",
                    "manuscript")
@@ -254,8 +254,8 @@ def create_task(payload):
                 raise ValueError("附件落盘失败: %s" % e)
         if items:
             task["attachments"] = items
-            task["context"] = att_mod.merge_context(
-                task["context"], items, workdir=str(wd))
+            task["context"] = att_mod.merge_context(
+                task["context"], items, workdir=str(wd))
     with LOCK:
         _TASKS[task["id"]] = task
         _save_json(paths.TASKS_DIR / (task["id"] + ".json"), task)
@@ -454,16 +454,16 @@ def load_all():
                 # 错误串（`[91m[1mError:`、U+FFFD 乱码墙），读盘时统一洗一遍——
                 # 老运行不必等重跑才干净（2026-09-20「咋还有乱码」实测）
                 _sanitize_run_text(r)
-                # 直接执行线程不跨进程：running 与无截止时间的 queued 是上次
-                # 进程中断残骸。带 resume_enqueue_at 的 queued 是有意的自动续跑
-                # 退避，保留给 jobs.restore_deferred_resumes 重建 Timer。
-                interrupted = (r.get("status") == "running" or
-                               (r.get("status") == "queued" and
-                                not r.get("resume_enqueue_at")))
-                if interrupted:
-                    r["status"] = "failed"
-                    r["error"] = r.get("error") or "服务重启中断，可重试"
-                    _save_json(p, r)
+                # 直接执行线程不跨进程：running 与无截止时间的 queued 是上次
+                # 进程中断残骸。带 resume_enqueue_at 的 queued 是有意的自动续跑
+                # 退避，保留给 jobs.restore_deferred_resumes 重建 Timer。
+                interrupted = (r.get("status") == "running" or
+                               (r.get("status") == "queued" and
+                                not r.get("resume_enqueue_at")))
+                if interrupted:
+                    r["status"] = "failed"
+                    r["error"] = r.get("error") or "服务重启中断，可重试"
+                    _save_json(p, r)
                 _RUNS[r["id"]] = r
             except Exception:
                 pass
@@ -486,16 +486,16 @@ def load_all():
 
 # ---------------------------------------------------------------- 运行（含管理操作）
 
-_RUN_ESTIMATOR = None
-
-
-def set_run_estimator(estimator):
-    """由应用入口注入 ETA 估算器，保持存储层不反向依赖用量模块。"""
-    global _RUN_ESTIMATOR
-    _RUN_ESTIMATOR = estimator if callable(estimator) else None
-
-
-def create_run(kind, title, task_id=None, entry_id=None, op=None):
+_RUN_ESTIMATOR = None
+
+
+def set_run_estimator(estimator):
+    """由应用入口注入 ETA 估算器，保持存储层不反向依赖用量模块。"""
+    global _RUN_ESTIMATOR
+    _RUN_ESTIMATOR = estimator if callable(estimator) else None
+
+
+def create_run(kind, title, task_id=None, entry_id=None, op=None):
     run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
         "kind": kind,  # orchestration | mgmt
@@ -505,20 +505,20 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
         "started_at": None, "ended_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
-        "verdict": None, "summary": "",
-    }
-    if kind == "orchestration" and task_id:
-        task = get_task(task_id) or {}
-        try:
-            eta = _RUN_ESTIMATOR(
-                task_type=task.get("type") or "", mode=task.get("mode") or "auto",
-                thinking=task.get("thinking") or "standard",
-                rounds=task.get("rounds"))
-            run["estimated_duration_s"] = eta.get("estimated_duration_s")
-            run["estimated_p90_s"] = eta.get("p90_duration_s")
-            run["estimate_source"] = eta.get("duration_source")
-        except Exception:
-            pass
+        "verdict": None, "summary": "",
+    }
+    if kind == "orchestration" and task_id:
+        task = get_task(task_id) or {}
+        try:
+            eta = _RUN_ESTIMATOR(
+                task_type=task.get("type") or "", mode=task.get("mode") or "auto",
+                thinking=task.get("thinking") or "standard",
+                rounds=task.get("rounds"))
+            run["estimated_duration_s"] = eta.get("estimated_duration_s")
+            run["estimated_p90_s"] = eta.get("p90_duration_s")
+            run["estimate_source"] = eta.get("duration_source")
+        except Exception:
+            pass
     rdir = paths.RUNS_DIR / run["id"]
     (rdir / "steps").mkdir(parents=True, exist_ok=True)
     with LOCK:
@@ -539,11 +539,11 @@ def get_run(run_id):
         return _RUNS.get(run_id)
 
 
-def list_runs(limit=60):
-    with LOCK:
-        ids = sorted(_RUNS.keys(), reverse=True)
-        selected = ids if limit is None else ids[:limit]
-        return [_RUNS[i] for i in selected]
+def list_runs(limit=60):
+    with LOCK:
+        ids = sorted(_RUNS.keys(), reverse=True)
+        selected = ids if limit is None else ids[:limit]
+        return [_RUNS[i] for i in selected]
 
 
 def latest_run_by_task():
@@ -668,17 +668,17 @@ def task_side(task_id):
     }
 
 
-def update_run(run_id, expected_status=None, **fields):
+def update_run(run_id, expected_status=None, **fields):
     """更新运行字段。expected_status 非 None 时做 CAS（§2C）：
     当前状态不等于 expected_status 则拒绝写入并返回 None，
     防止陈旧执行方（被取消的 worker、崩溃恢复前的旧线程）覆盖新状态
     ——防御模式「异步状态不是同步状态」。不传则保持原行为。"""
     with LOCK:
         run = _RUNS.get(run_id)
-        if not run:
-            return None
-        if expected_status is not None and run.get("status") != expected_status:
-            return None
+        if not run:
+            return None
+        if expected_status is not None and run.get("status") != expected_status:
+            return None
         for k in ("error", "summary"):
             if isinstance(fields.get(k), str):
                 # 错误串多是我们自己拼的 CLI 尾巴（含 ANSI/覆写/乱码墙）：
@@ -711,33 +711,33 @@ def update_run(run_id, expected_status=None, **fields):
         return run
 
 
-def run_dir(run_id):
-    return paths.RUNS_DIR / run_id
-
-
-def _schedule_run_dir_cleanup(run_id):
-    """把运行目录快速移出可见路径，再后台删除大日志目录。
-
-    删除任务/运行记录不能让 HTTP 请求同步递归扫描数千个日志文件。
-    同盘 rename 是 O(1)，原路径立即消失；后台失败也不会影响内存状态。
-    """
-    source = paths.RUNS_DIR / str(run_id)
-    if not source.exists():
-        return
-    target = paths.RUNS_DIR / (".deleting-%s-%s" % (run_id, secrets.token_hex(4)))
-    try:
-        source.rename(target)
-    except OSError:
-        target = source
-
-    def _remove():
-        shutil.rmtree(target, ignore_errors=True)
-
-    threading.Thread(target=_remove, name="codebee-delete-%s" % run_id[:12],
-                     daemon=True).start()
-
-
-def delete_run(run_id):
+def run_dir(run_id):
+    return paths.RUNS_DIR / run_id
+
+
+def _schedule_run_dir_cleanup(run_id):
+    """把运行目录快速移出可见路径，再后台删除大日志目录。
+
+    删除任务/运行记录不能让 HTTP 请求同步递归扫描数千个日志文件。
+    同盘 rename 是 O(1)，原路径立即消失；后台失败也不会影响内存状态。
+    """
+    source = paths.RUNS_DIR / str(run_id)
+    if not source.exists():
+        return
+    target = paths.RUNS_DIR / (".deleting-%s-%s" % (run_id, secrets.token_hex(4)))
+    try:
+        source.rename(target)
+    except OSError:
+        target = source
+
+    def _remove():
+        shutil.rmtree(target, ignore_errors=True)
+
+    threading.Thread(target=_remove, name="codebee-delete-%s" % run_id[:12],
+                     daemon=True).start()
+
+
+def delete_run(run_id):
     """删除一条运行记录（内存 + 磁盘目录）。返回 (ok, 错误信息)。"""
     if not _valid_id(run_id):
         return False, "非法的记录 ID"
@@ -748,7 +748,7 @@ def delete_run(run_id):
         if run.get("status") in ("queued", "running"):
             return False, "运行中的记录不能删除，请先取消"
         del _RUNS[run_id]
-    _schedule_run_dir_cleanup(run_id)
+    _schedule_run_dir_cleanup(run_id)
     bump_state()
     return True, ""
 
@@ -843,36 +843,36 @@ def run_workdir(run_id):
 _SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".idea", ".vscode"}
 
 # 构建产物/依赖缓存目录：里面的文件是工具链再生成的，不是任务成品
-_BUILD_DIRS = {
+_BUILD_DIRS = {
     "target", "build", "dist", "out", "bin", "obj",           # 通用构建输出
     "surefire", "failsafe-reports", "test-output", "reports",  # 测试/报告输出
     ".next", ".nuxt", ".output", ".gradle", ".gradle-home",    # 前端/Gradle
     "__MACOSX",
-}
-
-# CLI 自身的历史/评审中间件不属于用户成果。它们通常落在工作目录根部，
-# 只按隐藏目录过滤会漏掉 Aider 的 .aider.* 与流程生成的 *_review.json。
-_PROCESS_ARTIFACT_NAMES = {
-    ".aider.chat.history.md", ".aider.input.history", ".aider.input.history.md",
-    ".aider.tags.cache.v4", ".aider.tags.cache.v3", ".aider.conf.yml",
-}
-_PROCESS_ARTIFACT_SUFFIXES = ("_review.json", ".review.json")
-_PROCESS_ARTIFACT_PREFIXES = ("tutti_prompt_", "_tutti_prompt_")
-
-
-def _is_process_artifact(rel_name):
-    """判断工作目录文件是否为 CLI/评审过程产物，而非可交付成果。"""
-    name = str(rel_name or "").replace("\\", "/")
-    base = name.rsplit("/", 1)[-1].lower()
-    if base in _PROCESS_ARTIFACT_NAMES:
-        return True
-    if base.startswith(".") and base.startswith(".aider"):
-        return True
-    if base.endswith(_PROCESS_ARTIFACT_SUFFIXES):
-        return True
-    if base.startswith(_PROCESS_ARTIFACT_PREFIXES):
-        return True
-    return False
+}
+
+# CLI 自身的历史/评审中间件不属于用户成果。它们通常落在工作目录根部，
+# 只按隐藏目录过滤会漏掉 Aider 的 .aider.* 与流程生成的 *_review.json。
+_PROCESS_ARTIFACT_NAMES = {
+    ".aider.chat.history.md", ".aider.input.history", ".aider.input.history.md",
+    ".aider.tags.cache.v4", ".aider.tags.cache.v3", ".aider.conf.yml",
+}
+_PROCESS_ARTIFACT_SUFFIXES = ("_review.json", ".review.json")
+_PROCESS_ARTIFACT_PREFIXES = ("tutti_prompt_", "_tutti_prompt_")
+
+
+def _is_process_artifact(rel_name):
+    """判断工作目录文件是否为 CLI/评审过程产物，而非可交付成果。"""
+    name = str(rel_name or "").replace("\\", "/")
+    base = name.rsplit("/", 1)[-1].lower()
+    if base in _PROCESS_ARTIFACT_NAMES:
+        return True
+    if base.startswith(".") and base.startswith(".aider"):
+        return True
+    if base.endswith(_PROCESS_ARTIFACT_SUFFIXES):
+        return True
+    if base.startswith(_PROCESS_ARTIFACT_PREFIXES):
+        return True
+    return False
 
 
 def task_first_start(task_id, fallback=""):
@@ -933,10 +933,10 @@ def run_artifacts(run_id, limit=200):
                 continue
             if st.st_mtime < t0:
                 continue
-            rel_name = str(p.relative_to(root)).replace("\\", "/")
-            if _is_process_artifact(rel_name):
-                continue
-            files.append({"name": rel_name,
+            rel_name = str(p.relative_to(root)).replace("\\", "/")
+            if _is_process_artifact(rel_name):
+                continue
+            files.append({"name": rel_name,
                           "size": st.st_size, "mtime": int(st.st_mtime)})
             if len(files) >= 800:  # 防超大目录拖垮接口；截断后再排序取最新
                 break
@@ -1108,7 +1108,7 @@ def delete_runs(run_ids):
                 skipped += 1
                 continue
             del _RUNS[rid]
-        _schedule_run_dir_cleanup(rid)
+        _schedule_run_dir_cleanup(rid)
         deleted += 1
     if deleted:
         bump_state()
@@ -1127,7 +1127,7 @@ def clear_runs():
         for rid in targets:
             del _RUNS[rid]
     for rid in targets:
-        _schedule_run_dir_cleanup(rid)
+        _schedule_run_dir_cleanup(rid)
     bump_state()
     return len(targets), skipped
 
@@ -1166,9 +1166,9 @@ def delete_task(task_id):
         del _TASKS[task_id]
         for rid in run_ids:
             _RUNS.pop(rid, None)
-    for rid in run_ids:
-        _schedule_run_dir_cleanup(rid)
-    (paths.TASKS_DIR / (task_id + ".json")).unlink(missing_ok=True)
+    for rid in run_ids:
+        _schedule_run_dir_cleanup(rid)
+    (paths.TASKS_DIR / (task_id + ".json")).unlink(missing_ok=True)
     bump_state()
     return True, ""
 
@@ -1431,6 +1431,43 @@ def rename_task(task_id, title):
     return True, ""
 
 
+def update_task_params(task_id, patch):
+    """更新任务编排参数（对话条三件套：mode/thinking/direct_provider_id/direct_model）。
+    只在任务未在跑时生效——运行中改参数不会影响当前执行，静默跳过避免误导。"""
+    if not _valid_id(task_id):
+        return False, "非法的任务 ID"
+    with LOCK:
+        task = _TASKS.get(task_id)
+        if not task:
+            return False, "任务不存在"
+        if task.get("status") in ("queued", "running"):
+            return False, "任务运行中，参数不可改"
+        changed = False
+        mode = str((patch or {}).get("mode") or "").strip()
+        if mode in ("auto", "fast", "expert", "manual"):
+            if task.get("mode") != mode:
+                task["mode"] = mode
+                changed = True
+        thinking = str((patch or {}).get("thinking") or "").strip()
+        if thinking in ("auto", "low", "standard", "high"):
+            if task.get("thinking") != thinking:
+                task["thinking"] = thinking
+                changed = True
+        if task.get("engine") == "direct":
+            pv = str((patch or {}).get("direct_provider_id") or "").strip()[:80]
+            mv = str((patch or {}).get("direct_model") or "").strip()[:160]
+            if mv and not pv:
+                return False, "指定对话模型时必须同时指定厂商"
+            if task.get("direct_provider_id") != pv or task.get("direct_model") != mv:
+                task["direct_provider_id"] = pv
+                task["direct_model"] = mv
+                changed = True
+        if changed:
+            _save_json(paths.TASKS_DIR / (task_id + ".json"), task)
+            bump_state()
+    return True, ""
+
+
 def add_step(run_id, role, agent_id, agent_label, note=""):
     with LOCK:
         run = _RUNS.get(run_id)

package/app/main.py

@@ -622,7 +622,7 @@ class Handler(BaseHTTPRequestHandler):
             return self._api_dir_save()
         if path == "/api/pick_folder":
             return self._api_pick_folder()
-        m = re.match(r"^/api/tasks/([^/]+)/(archive|delete|retry|rename|continue)$", path)
+        m = re.match(r"^/api/tasks/([^/]+)/(archive|delete|retry|rename|continue|params)$", path)
         if m:
             if m.group(2) == "archive":
                 body = self._body()
@@ -677,6 +677,9 @@ class Handler(BaseHTTPRequestHandler):
                                         "run_id": run["id"]})
             elif m.group(2) == "rename":
                 ok, err = store.rename_task(m.group(1), self._body().get("title"))
+            elif m.group(2) == "params":
+                # 对话条三件套（mode/thinking/direct 模型）随发随改：只许空闲态改
+                ok, err = store.update_task_params(m.group(1), self._body())
             else:
                 ok, err = store.delete_task(m.group(1))
             return self._json(400, {"error": err}) if not ok else self._json(200, {"ok": True})

package/app/ui/app.js

@@ -6581,6 +6581,12 @@ async function renderChat(run, active) {
   const continueNote = $("rd-chat-continue-note");
   if (continueNote) continueNote.classList.toggle("hidden", !!active);
   if (chatRunId !== run.id) { chatRunId = run.id; chatAtts = []; drawChatAtts(); chatSig = ""; }
+  // 三件套回填：任务对象来自 S.state（渲染时已就位）；只在任务未在跑时回显，
+  // 防止轮询把用户正在改的值弹回（select change 重绘弹回教训）
+  if (run.status !== "running" && run.status !== "queued" && S.state) {
+    const task = (S.state.tasks || []).find((x) => x.id === run.task_id);
+    if (task) rdPrefsFill(task);
+  }
   const sig = run.id + "|" + run.status + "|" + (run.steps || []).length +
     "|" + ((run.messages || []).length);
   if (sig === chatSig) return;   // 轮询重画去抖：内容没变不重建 DOM（保住输入焦点）
@@ -6856,15 +6862,145 @@ function renderDetailOverview(run, runs, task) {
   box.classList.remove("hidden");
 }
 
+/* 对话条三件套：与任务参数双向同步（2026-09-21 用户反馈「这里面也需要同步改」）。
+ * 回填自当前任务；改动即写任务（空闲态），发送 /chat 前再兜底同步一次。 */
+let rdPrefsTaskId = "";
+let rdModelPv = "", rdModelMv = "";   // 对话条当前模型选择（厂商 id + 模型名）
+
+function rdPrefsFill(task) {
+  if (!task) return;
+  const set1 = (id, v, allow) => { const el = $(id); if (el && allow.includes(v)) el.value = v; };
+  set1("rd-mode", task.mode, ["auto", "fast", "expert", "manual"]);
+  set1("rd-thinking", task.thinking, ["auto", "low", "standard", "high"]);
+  if (rdPrefsTaskId !== task.id) {
+    rdPrefsTaskId = task.id;
+    rdModelPv = task.direct_provider_id || "";
+    rdModelMv = task.direct_model || "";
+  }
+  ["rd-mode", "rd-thinking"].forEach((id) => syncCmpSelFace(id));
+  rdModelFaceSync();
+}
+
+function rdModelFaceSync() {
+  const face = $("rd-model-btn");
+  if (!face) return;
+  if (!rdModelPv) { face.textContent = t("自动推荐"); return; }
+  const p = directProviders().find((x) => x.id === rdModelPv);
+  face.textContent = (p ? (p.name || p.id) : rdModelPv) +
+    (rdModelMv ? "/" + rdModelMv : "/" + t("推荐"));
+}
+
+/* 对话条模型菜单（与新建 composer 的 cmp-model-menu 同款两级钻取，独立实例） */
+let rdMenuProv = "";
+
+function rdModelMenuRender() {
+  const menu = $("rd-model-menu");
+  if (!menu) return;
+  const chk = '<svg class="ico ti-check" aria-hidden="true"><use href="#i-check"></use></svg>';
+  const arr = '<svg class="ico ti-check" aria-hidden="true"><use href="#i-chevron-r"></use></svg>';
+  if (!rdMenuProv) {
+    menu.innerHTML =
+      '<button type="button" class="type-item" data-p="" data-m=""><span class="ti-body"><span class="ti-name">' +
+        t("自动推荐") + "</span></span>" + (!rdModelPv ? chk : "") + "</button>" +
+      directProviders().map((p) =>
+        '<button type="button" class="type-item" data-p="' + esc(p.id) + '"><span class="ti-body"><span class="ti-name">' +
+        esc(p.name || p.id) + "</span></span>" + (rdModelPv === p.id ? chk : arr) + "</button>").join("") +
+      '<div class="type-menu-foot"><button type="button" class="type-item" data-manage="1"><span class="ti-body"><span class="ti-name">' +
+        t("管理模型…") + "</span></span></button></div>";
+  } else {
+    const p = directProviders().find((x) => x.id === rdMenuProv);
+    const names = p ? (p.models || []).filter((m) => !m.hidden)
+      .map((m) => m.name).filter(Boolean) : [];
+    menu.innerHTML =
+      '<button type="button" class="type-item" data-back="1"><span class="ti-body"><span class="ti-name">‹ ' +
+        esc(p ? (p.name || p.id) : rdMenuProv) + "</span></span></button>" +
+      '<button type="button" class="type-item" data-p="' + esc(rdMenuProv) + '" data-m=""><span class="ti-body"><span class="ti-name">' +
+        t("随厂商推荐") + "</span></span>" + (rdModelPv === rdMenuProv && !rdModelMv ? chk : "") + "</button>" +
+      names.map((n) =>
+        '<button type="button" class="type-item" data-p="' + esc(rdMenuProv) + '" data-m="' + esc(n) + '"><span class="ti-body"><span class="ti-name">' +
+        esc(n) + "</span></span>" + (rdModelPv === rdMenuProv && rdModelMv === n ? chk : "") + "</button>").join("");
+  }
+}
+
+function toggleRdModelMenu(force) {
+  const menu = $("rd-model-menu");
+  if (!menu) return;
+  const show = force !== undefined ? force : menu.classList.contains("hidden");
+  if (show) { rdMenuProv = ""; rdModelMenuRender(); }
+  menu.classList.toggle("hidden", !show);
+}
+window.toggleRdModelMenu = toggleRdModelMenu;
+
+(function () {
+  const menu = $("rd-model-menu");
+  if (!menu || menu.dataset.rdBound) return;
+  menu.dataset.rdBound = "1";
+  menu.addEventListener("click", (e) => {
+    e.stopPropagation();   // 同 cmp-model-menu：防「点外面收起」误判（DOM 重写竞态）
+    const b = e.target.closest("[data-p],[data-back],[data-manage]");
+    if (!b) return;
+    if (b.dataset.manage) { toggleRdModelMenu(false); switchTab("models"); return; }
+    if (b.dataset.back) { rdMenuProv = ""; rdModelMenuRender(); return; }
+    if (b.dataset.m === undefined) { rdMenuProv = b.dataset.p; rdModelMenuRender(); return; }
+    rdModelPv = b.dataset.p;
+    rdModelMv = b.dataset.m;
+    rdModelFaceSync();
+    toggleRdModelMenu(false);
+    rdPrefsPush("model");
+  });
+  document.addEventListener("click", (e) => {
+    const wrap = $("rd-model-wrap");
+    if (wrap && !wrap.contains(e.target)) toggleRdModelMenu(false);
+  });
+  document.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") toggleRdModelMenu(false);
+  });
+})();
+
+async function rdPrefsPush(what) {
+  // what: mode|thinking|model（变更源）；写任务参数（空闲态才允许）
+  const task = (S.lastRun && S.lastRun.task_id && S.state &&
+    (S.state.tasks || []).find((x) => x.id === S.lastRun.task_id)) || null;
+  if (!task) return;
+  const patch = {};
+  if (what === "mode") patch.mode = $("rd-mode").value;
+  if (what === "thinking") patch.thinking = $("rd-thinking").value;
+  if (what === "model") {
+    patch.direct_provider_id = rdModelPv;
+    patch.direct_model = rdModelMv;
+  }
+  try {
+    await api("/api/tasks/" + encodeURIComponent(task.id) + "/params", {
+      method: "POST", operation: false, body: JSON.stringify(patch) });
+  } catch (e) { /* 运行中/网络失败不打断对话，发送前还有兜底 */ }
+}
+
+async function rdPrefsPushAll() {
+  // 发送前兜底：三个一起推（/chat 开新一轮前调用；失败静默——值已在前端，
+  // 下一轮 poll 的回填也不会覆盖用户刚选的值）
+  await Promise.all([rdPrefsPush("mode"), rdPrefsPush("thinking"), rdPrefsPush("model")]);
+}
+
 function drawChatAtts() {
   const box = $("rd-chat-att-list");
   if (!box) return;
-  // 点名字开预览（待提交区原文走 /api/attachments/<id>），× 才是移除
-  box.innerHTML = chatAtts.map((a, i) =>
-    '<span class="att-chip2 att-view" data-att-id="' + esc(a.id || "") +
-    '" data-att-name="' + esc(a.name) + '" title="' + esc(t("点击查看")) + '">' + esc(a.name) +
-    '<b onclick="chatRemoveAtt(' + i + ')" title="' + esc(t("移除")) + '">×' +
-    '</b></span>').join("");
+  // 点名字开预览（待提交区原文走 /api/attachments/<id>），× 才是移除。
+  // 图片直接展示缩略图（2026-09-21 用户反馈「图片要展示出来」）
+  box.innerHTML = chatAtts.map((a, i) => {
+    const isImg = /^image\//i.test(String(a.mime || "")) ||
+      /\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(a.name || "");
+    if (isImg && a.id) {
+      const src = "/api/attachments/" + encodeURIComponent(a.id) + qsAuth();
+      return '<span class="att-view rd-att-thumb" data-att-id="' + esc(a.id) +
+        '" data-att-name="' + esc(a.name) + '" title="' + esc(a.name) + '">' +
+        '<img src="' + esc(src) + '" alt="' + esc(a.name) + '" loading="lazy" draggable="false">' +
+        '<b onclick="chatRemoveAtt(' + i + ')" title="' + esc(t("移除")) + '">×</b></span>';
+    }
+    return '<span class="att-chip2 att-view" data-att-id="' + esc(a.id || "") +
+      '" data-att-name="' + esc(a.name) + '" title="' + esc(t("点击查看")) + '">' + esc(a.name) +
+      '<b onclick="chatRemoveAtt(' + i + ')" title="' + esc(t("移除")) + '">×' +
+      '</b></span>';
+  }).join("");
 }
 window.chatRemoveAtt = function (i) { chatAtts.splice(i, 1); drawChatAtts(); };
 
@@ -6923,6 +7059,8 @@ window.chatSend = async function () {
       });
       toast(t("已排队：随下一步一起送达"));
     } else {
+      // 空闲态发送：先把三件套落到任务（变更即推失败时的兜底），再开新一轮
+      await rdPrefsPushAll();
       const r = await api("/api/runs/" + encodeURIComponent(chatRunId) + "/chat", {
         method: "POST",
         body: JSON.stringify({ text, attachments: chatAtts.map((a) => a.id) }),
@@ -7015,6 +7153,9 @@ function bindChat() {
     const chip = e.target.closest("[data-att-id]");
     if (chip) window.chatPendingPopup(chip.dataset.attId, chip.dataset.attName);
   });
+  // 对话条三件套：改动即写任务参数（空闲态），face 跟随
+  $("rd-mode").addEventListener("change", () => { syncCmpSelFace("rd-mode"); rdPrefsPush("mode"); });
+  $("rd-thinking").addEventListener("change", () => { syncCmpSelFace("rd-thinking"); rdPrefsPush("thinking"); });
   // 语音输入（借鉴 paseo voice control）：Web Speech API 口述转文字填入输入框。
   // 仅浏览器支持时显示按钮（Chrome/Edge）；识别结果追加到光标处，不自动发送。
   bindVoiceInput();

package/app/ui/index.html

@@ -492,6 +492,33 @@
                   <button id="rd-chat-voice" class="ghost hidden" data-i18n-title="语音输入（口述转文字填入输入框）" title="语音输入（口述转文字填入输入框）" data-i18n-aria="语音输入" aria-label="语音输入"><svg class="ico" aria-hidden="true"><use href="#i-mic"></use></svg></button>
                   <span id="rd-chat-att-list" class="rd-att-list"></span>
                   <span id="rd-chat-hint" class="rd-hint"></span>
+                  <!-- 对话条三件套（2026-09-21 用户反馈「这里面也需要同步改」）：与
+                       新建 composer 同款 pill；改动即写任务参数（空闲态），发送立即生效 -->
+                  <span class="cmp-sel" data-i18n-title="编排模式" title="编排模式">
+                    <select id="rd-mode" class="cmp-sel-native" aria-label="编排模式" data-i18n-aria="编排模式">
+                      <option data-i18n="自动：按任务类型与风险动态决定步骤" value="auto">自动：按任务类型与风险动态决定步骤</option>
+                      <option data-i18n="快速：少步骤优先，先做确定性验收" value="fast">快速：少步骤优先，先做确定性验收</option>
+                      <option data-i18n="专家：完整规划、多评审、失败修复与换将" value="expert">专家：完整规划、多评审、失败修复与换将</option>
+                      <option data-i18n="手动：自行指定实现者与评审组" value="manual">手动：自行指定实现者与评审组</option>
+                    </select>
+                    <span class="cmp-sel-face" id="rd-mode-face">自动</span>
+                    <svg class="ico chev" aria-hidden="true"><use href="#i-chevron-r"></use></svg>
+                  </span>
+                  <span class="cmp-sel" data-i18n-title="思考程度" title="思考程度">
+                    <select id="rd-thinking" class="cmp-sel-native" aria-label="思考程度" data-i18n-aria="思考程度">
+                      <option data-i18n="标准：平衡质量与速度" value="standard" selected>标准：平衡质量与速度</option>
+                      <option data-i18n="自动：随任务难度调整" value="auto">自动：随任务难度调整</option>
+                      <option data-i18n="快速：少推理、优先响应" value="low">快速：少推理、优先响应</option>
+                      <option data-i18n="深度：更多推理与检查" value="high">深度：更多推理与检查</option>
+                    </select>
+                    <span class="cmp-sel-face" id="rd-thinking-face">标准</span>
+                    <svg class="ico chev" aria-hidden="true"><use href="#i-chevron-r"></use></svg>
+                  </span>
+                  <span class="cmp-sel" id="rd-model-wrap" data-i18n-title="对话模型" title="对话模型">
+                    <button type="button" class="cmp-sel-face cmp-sel-btn" id="rd-model-btn" onclick="toggleRdModelMenu()" aria-haspopup="menu" aria-controls="rd-model-menu">自动推荐</button>
+                    <svg class="ico chev" aria-hidden="true"><use href="#i-chevron-r"></use></svg>
+                    <div id="rd-model-menu" class="type-menu hidden" role="menu" aria-label="对话模型" data-i18n-aria="对话模型"></div>
+                  </span>
                   <button id="rd-chat-send" class="primary round" data-i18n-title="发送" title="发送" data-i18n-aria="发送" aria-label="发送"><svg class="ico" aria-hidden="true"><use href="#i-arrow-up"></use></svg></button>
                 </div>
                 <input id="rd-chat-file" type="file" multiple accept=".png,.jpg,.jpeg,.gif,.webp,.bmp,.svg,.txt,.md,.markdown,.csv,.json,.log,.py,.js,.ts,.html,.css,.xml,.yml,.yaml,.toml,.pdf,.docx,.xlsx,.pptx" class="hidden" />

package/app/ui/style.css

@@ -5681,3 +5681,18 @@ button.request-busy > * { opacity: .18; }
 .chat-img img { display: block; width: 96px; height: 96px; object-fit: cover;
   border-radius: 10px; border: 1px solid var(--border); background: var(--panel2); }
 .chat-atts { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 8px; }
+
+/* 对话输入条待发图片：小缩略卡（2026-09-21 用户反馈「图片要展示出来」）。
+ * 44×44 内嵌在 rd-att-list 行内，不越出 chat-bar 边框；× 悬浮右上角 */
+.rd-att-list .rd-att-thumb { position: relative; width: 44px; height: 44px; padding: 0;
+  border: 1px solid var(--border-strong); border-radius: 8px; overflow: visible;
+  display: inline-flex; align-items: center; justify-content: center; cursor: zoom-in; }
+.rd-att-list .rd-att-thumb img { width: 100%; height: 100%; object-fit: cover;
+  border-radius: 7px; display: block; }
+.rd-att-list .rd-att-thumb b { position: absolute; top: -7px; right: -7px; z-index: 2;
+  width: 16px; height: 16px; border-radius: 50%; background: var(--panel);
+  border: 1px solid var(--border-strong); display: inline-flex; align-items: center;
+  justify-content: center; font-size: 11px; line-height: 1; }
+/* 气泡图片缩略图：限制在气泡内（曾压住输入框边框线——2026-09-21 用户反馈） */
+.chat-img img { box-sizing: border-box; }
+.chat-bubble { overflow-wrap: anywhere; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebee",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "CodeBee · 多智能体编排台 — 统一编排本机 AI 编码 CLI（Codex / Claude Code / QwenCode / OpenCode / Aider…）：目标→拆解→路由→执行→验证→跨厂商评审→修复→报告。纯 Python 标准库实现，本地 Web UI。",
   "license": "MIT",
   "bin": {