codebee 0.1.20 → 0.1.21

package/CHANGELOG.md

@@ -6,6 +6,12 @@ README 元数据带回，供老版本在「发现新版本」时展示新版更
 
 ## 未发布
 
+## v0.1.21（2026-09-21）
+
+- 任务默认直接启动，不再进入容量等待队列；达到并发保护上限立即失败并明确提示稍后重试，历史 queued 记录启动时自动接管或收口。
+- 修复取消竞态：编排、管理、自升级、禅道修复在取消后不会复活；自动续跑重启恢复不再受隐藏数量上限影响，并显示明确的续跑时间。
+- 定时任务、重试、续写、答疑和禅道修复统一使用同一套启动失败收口逻辑，避免任务长期停留在待启动状态。
+
 ## v0.1.20（2026-09-20）
 
 - 全类型交付契约：小说、文章、短视频、文档、翻译、调研、演讲、汇报、邮件、技术方案、简历按真实类型路由，并注入各自角色、成品结构和真实性约束

package/README.md

@@ -21,8 +21,10 @@ Kimi Code、MiMo Code、Grok Build、Pi、DeepSeek Harness……），提供
 不会把你的任务内容交给任何第三方。
 
 <!-- relnotes:start -->
-### 最新版更新内容（v0.1.20）
+### 最新版更新内容（v0.1.21）
 
+- 任务默认直接启动，不进入容量等待队列；满载立即失败并提示稍后重试，自动续跑退避会显示预定时间
+- 取消竞态修复：编排、管理、自升级、禅道修复取消后不会复活，重启可恢复全部定时续跑
 - 11 类内容任务按真实类型路由，并带各自角色、成品结构和真实性约束
 - token 预算恢复有效：默认路径与续会话均累计真实 usage，压缩重试不重复记账
 - 15 种流程成本预估全覆盖；修复 rubric 串值、预置流程误建副本和 direct 标签
@@ -108,7 +110,7 @@ OpenCode / Continue / Cursor / Trae 十种工具的配置，一次带入全部
   跑完整代码链，修完自动合并；双端问题修完我方部分后带修复报告转派另一端负责人，
   非我方转回报告人；测试指错人也按排查结论改派；修复失败自动升级转派；群机器人
   全程播报（设置页「禅道」子页配置）；
-- **多任务并发**：worker 池默认 3（1-6 可调），互不打扰；连载任务超时/中断自动
+- **多任务并发**：任务默认立即启动、无等待队列，并发保护上限默认 12；连载任务超时/中断自动
   断点续跑；
 - **远程访问**：手机同一 WiFi 直开、Tailscale 外网可达、Cloudflare Tunnel 固定
   域名——8 位访问令牌保护，多端实时同步（SSE），单设备控制权防互踩；
@@ -316,10 +318,10 @@ start-public.bat
 
 ## 多任务并发
 
-任务队列是可并发 worker 池（默认 3，设置页「编排设置」可调 1-6）：多个任务同时跑、
-互不打扰——每个任务独立线程，运行数据按 run 隔离，互不等待。并发数调小后多余线程
-在空闲检查点自行退出，调大即时补齐。串行模式（=1）也可用。连载任务超时/中断自动
-断点续跑（延迟退避入队，防在网关限流墙上连续撞死）。
+任务执行器采用直接启动模式（并发保护上限默认 12，设置页「编排设置」可调 1-12）：多个任务同时跑、
+互不打扰——每个任务独立线程，运行数据按 run 隔离，不进入等待队列。达到保护上限时本次请求明确失败并提示稍后重试；并发数调小只影响后续任务，已有任务继续完成。
+连载任务超时/中断会自动断点续跑；重试前按明确时间退避，防止在网关限流墙上连续撞死，
+这段等待不占执行位，也不属于任务容量排队。
 
 ## 编排设置（编排者模型）
 

package/app/core/automation.py

@@ -292,7 +292,7 @@ def _recover_after_restart():
 
 def _launch_run(t):
     """拉起一次真实编排运行：与 main.py 的 /api/tasks 走同一条链路
-    （store.create_task → store.create_run → jobs 入队），返回 run_id。
+    （store.create_task → store.create_run → jobs 直接启动），返回 run_id。
     测试可把本函数打成 stub，绝不真调 LLM/CLI。"""
     payload = {"type": t.get("flow") or DEFAULT_FLOW,
                "title": ("%s %s" % (t.get("name") or "定时任务",
@@ -309,15 +309,15 @@ def _launch_run(t):
                       "task_id": task["id"]})
         return run["id"]
     except Exception:
-        # A scheduler failure must not leave a task/run that looks queued forever.
+        # 启动失败必须收口，不能留下看似仍在启动的任务/run。
         # Keep the public error generic; the detailed traceback stays in the
         # service log and the run record remains useful for diagnostics.
-        log.exception("automation: 运行入队失败 task=%s run=%s",
+        log.exception("automation: 运行启动失败 task=%s run=%s",
                       (task or {}).get("id"), (run or {}).get("id"))
         if run:
             try:
                 store.update_run(run["id"], status="failed",
-                                 error="任务入队失败，请稍后重试",
+                                 error="任务启动失败，本次未排队，请稍后重试",
                                  ended_at=time.strftime("%Y-%m-%d %H:%M:%S"))
             except Exception:
                 log.exception("automation: 运行失败收口失败 run=%s", run.get("id"))
@@ -334,7 +334,7 @@ def _launch_run(t):
 def _fire(snapshot, now):
     """触发一个到期任务：拉起运行并推进 last_run/next_run/run_count/last_status。
     once 触发完自动停用。拉起失败只记 error，next_run 照常推进（下个周期重试）。"""
-    status = "queued"
+    status = "started"
     try:
         _launch_run(snapshot)
     except Exception as e:
@@ -527,7 +527,7 @@ def run_now(tid):
         return None, None
     now = datetime.now()
     run_id = ""
-    status = "queued"
+    status = "started"
     try:
         with _LOCK:
             snapshot = dict(_TASKS[tid])

package/app/core/capability.py

@@ -13,6 +13,8 @@ from __future__ import annotations
 
 import re
 
+from .dispatch import TYPE_DIMENSIONS
+
 # 能力维度（先固化清单，schema 见设计稿）
 DIMS = ("writing", "coding", "reasoning", "vision")
 
@@ -33,6 +35,9 @@ def classify_task_type(task) -> str:
     explicit = str((task or {}).get("task_type") or "").strip().lower()
     if explicit in DIMS:
         return explicit
+    preset = str((task or {}).get("type") or "").strip().lower()
+    if preset in TYPE_DIMENSIONS:
+        return TYPE_DIMENSIONS[preset]
     text = "%s %s" % ((task or {}).get("type") or "",
                       (task or {}).get("goal") or "")
     scores = {}
@@ -92,7 +97,8 @@ def resolve_binding_by_task(task, providers, bindings):
 TIER_ORDER = {"budget": 0, "standard": 1, "premium": 2}
 
 
-def cascade_reorder(agent, tier_of):
+def cascade_reorder(agent, tier_of, *, providers=None, pricing=None,
+                    difficulty="easy", task_type="", role=""):
     """FrugalGPT 式便宜优先：easy 任务把 call_chain 按 tier 升序稳定重排。
 
     agent 来自 modelhub.bind_agent（可能带 call_chain）；tier_of(chain_entry)
@@ -102,6 +108,14 @@ def cascade_reorder(agent, tier_of):
     chain = (agent or {}).get("call_chain") or []
     if len(chain) < 2:
         return agent
+    if providers is not None and (task_type or role):
+        from .dispatch import rank_model_entries
+        ranked, _decisions = rank_model_entries(
+            chain, {p.get("id"): p for p in providers or []},
+            pricing or {}, difficulty, task_type, role)
+        out = dict(agent)
+        out["call_chain"] = ranked
+        return out
 
     def key(entry):
         return TIER_ORDER.get(tier_of(entry) or "standard", 1)
@@ -127,4 +141,4 @@ def make_tier_lookup(providers):
             if isinstance(m, dict) and m.get("name") == (entry or {}).get("model"):
                 return m.get("tier") or p.get("tier")
         return p.get("tier")
-    return tier_of
+    return tier_of

package/app/core/catalog.py

@@ -154,7 +154,7 @@ DEFAULT_CATALOG = [
         "note": "DeepSeek 官方 agent harness（dsh，profile 插件架构）；无头是「一次性任务」——"
                 "答完即退、无交互后续、不支持会话恢复；任务只走位置参数（超长提示词受 Windows "
                 "命令行上限约 32k 约束）；模型写进 ~/.dsh/settings.yaml 的 agent-default-model.model；"
-                "密钥由「CLI 绑定」注入 DEEPSEEK_API_KEY（优先级最高）；端点注入 DEEPSEEK_BASE_URL，"
+                "密钥由运行时自动调度或「模型调度（可选）」注入 DEEPSEEK_API_KEY（优先级最高）；端点注入 DEEPSEEK_BASE_URL，"
                 "但若 settings.yaml 已固定 llm-deepseek.baseURL，则以它为准（settings 高于 env）",
         "detect": {"cli": "dsh"},
         "orch": {"kind": "generic", "command": "dsh",

package/app/core/covergen.py

@@ -42,17 +42,53 @@ _IMAGE_MODEL_KEYWORDS = ("cogview", "dall-e", "gpt-image", "flux", "kolors",
 _SIZES = ("768x1344", "1024x1024")   # 竖版优先，方图兜底
 
 
+def _chapter_facts(workdir, limit=3):
+    """从最新章节抽取视觉事实（借鉴 poster-v2 的 novel fact extraction）：
+    人物/场景/关键意象的原文片段——封面元素来自真实剧情而非干瘪题材词。
+    读不到章节（单稿/未开写）返回空串，提示词回落题材+简介。"""
+    if not workdir:
+        return ""
+    import glob as _glob
+    try:
+        chapters = sorted(_glob.glob(str(workdir) + "/chapter-*.md"))
+        if not chapters:
+            return ""
+        facts = []
+        for p in chapters[-limit:]:
+            try:
+                with open(p, encoding="utf-8", errors="replace") as f:
+                    txt = f.read(4000)
+                # 取开头（多为场景/人物动作）+ 关键句粗筛
+                head = " ".join(txt.split("\n")[1:6])
+                if head.strip():
+                    facts.append(head.strip()[:200])
+            except OSError:
+                continue
+        return "\n".join(facts)[:900]
+    except Exception:
+        return ""
+
+
 def _cover_prompt(task):
-    """从任务与建书资料拼图像提示词：场景氛围向，不要文字（平台会自行压字）。"""
+    """从任务与建书资料拼图像提示词：场景氛围向，不要文字（平台会自行压字）。
+
+    素材优先级：章节事实抽取（真实剧情的人物/场景/意象）> 题材+简介。
+    poster-v2 借鉴：视觉元素来自 novel facts 才有「这是这本书的封面」的辨识度。"""
     bm = ((task.get("book_meta") or {}).get("fanqie") or {}).get("data") or {}
     if not isinstance(bm, dict):
         bm = {}
     title = bm.get("书名") or task.get("title") or ""
     genre = bm.get("类型") or bm.get("分类") or ""
     brief = (bm.get("一句话简介") or bm.get("简介") or task.get("goal") or "")
-    return ("竖版小说封面插画，画面中不要出现任何文字。题材：%s %s。故事梗概：%s。"
-            "商业网文封面质感：主体人物或核心场景突出，色彩浓郁有冲击力，"
-            "构图上方留白便于后期压标题。" % (genre, title, str(brief)[:300]))
+    facts = _chapter_facts(task.get("workdir") or "")
+    base = ("竖版小说封面插画，画面中不要出现任何文字。题材：%s %s。故事梗概：%s。"
+            % (genre, title, str(brief)[:300]))
+    if facts:
+        base += ("\n\n以下是最新的剧情片段（从中提取主要人物形象、标志性场景与核心意象"
+                 "作为画面主体——让封面一眼可辨「这是这本书」）：\n%s" % facts)
+    base += ("\n商业网文封面质感：主体人物或核心场景突出，色彩浓郁有冲击力，"
+             "构图上方留白便于后期压标题。")
+    return base
 
 
 def _pick_key(prov):

package/app/core/dispatch.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""统一调度评分：任务画像、CLI 亲和度与模型链排序。
+
+本模块只做纯计算，不读写配置和运行状态。调用方先完成协议、启停、健康、
+密钥等硬约束过滤，再把可用候选交给这里评分；相同分数保持用户原顺序。
+"""
+from __future__ import annotations
+
+import math
+
+
+TYPE_DIMENSIONS = {
+    "direct": "reasoning",
+    "code": "coding",
+    "novel": "writing",
+    "serial_novel": "writing",
+    "article": "writing",
+    "video_script": "writing",
+    "doc": "writing",
+    "translation": "writing",
+    "rank_scan": "reasoning",
+    "research": "reasoning",
+    "speech": "writing",
+    "weekly_report": "writing",
+    "email": "writing",
+    "tech_proposal": "reasoning",
+    "resume": "writing",
+    "zentao": "coding",
+}
+
+_KIND_AFFINITY = {
+    "coding": {"codex": 10, "aider": 8, "opencode": 7, "qwen": 6,
+               "claude": 5, "generic": 2},
+    "writing": {"claude": 10, "qwen": 7, "generic": 5, "codex": 3,
+                "opencode": 2, "aider": 0},
+    "reasoning": {"claude": 9, "codex": 8, "qwen": 6, "opencode": 4,
+                  "generic": 3, "aider": 1},
+    "vision": {"codex": 10, "claude": 8, "qwen": 5, "opencode": 2,
+               "generic": 1, "aider": 0},
+}
+
+_TIER_SCORE = {
+    "easy": {"budget": 18.0, "standard": 8.0, "premium": -6.0},
+    "default": {"budget": 2.0, "standard": 6.0, "premium": 5.0},
+    "hard": {"budget": -8.0, "standard": 4.0, "premium": 12.0},
+}
+
+
+def task_dimension(task_type, role=""):
+    """把预置任务与步骤角色归一为 writing/coding/reasoning/vision。"""
+    ttype = str(task_type or "").strip().lower()
+    role = str(role or "").strip().lower()
+    if ttype in ("writing", "coding", "reasoning", "vision"):
+        return ttype
+    if role in ("plan", "review", "critique", "selector", "qa") \
+            or "review" in role or "critique" in role:
+        return "reasoning"
+    return TYPE_DIMENSIONS.get(ttype, "reasoning")
+
+
+def agent_affinity(kind, task_type, role=""):
+    """CLI 类型对任务维度的温和偏好；只作加分，不覆盖健康与历史信号。"""
+    dim = task_dimension(task_type, role)
+    score = float((_KIND_AFFINITY.get(dim) or {}).get(kind, 0))
+    if role == "review" or "critique" in str(role or ""):
+        score += {"claude": 4, "codex": 3, "qwen": 2}.get(kind, 0)
+    return score, "%s 匹配 %+.1f" % (dim, score)
+
+
+def _model_meta(provider, model):
+    for item in (provider or {}).get("models") or []:
+        if isinstance(item, dict) and item.get("name") == model:
+            return item
+    return {}
+
+
+def _price_score(pricing, model, difficulty):
+    price = (pricing or {}).get(model) or {}
+    try:
+        # 输出通常比输入贵且更影响整步成本，按 2 倍权重估算。
+        blended = max(0.0, float(price.get("in") or 0.0)
+                      + 2.0 * float(price.get("out") or 0.0))
+    except (TypeError, ValueError):
+        return 0.0, "价格未知"
+    if blended <= 0:
+        return 0.0, "价格未知"
+    magnitude = max(0.0, math.log10(blended + 1.0))
+    score = -min(18.0, magnitude * (7.0 if difficulty == "easy" else 2.0))
+    return score, "估算价 %.3g（%+.1f）" % (blended, score)
+
+
+def score_model_entry(entry, providers, pricing, difficulty, task_type="", role=""):
+    """给已通过硬约束的模型链条目评分，返回 (score, explanation)。"""
+    provider = (providers or {}).get(entry.get("provider_id")) \
+        or entry.get("provider") or {}
+    model = entry.get("model") or ""
+    meta = _model_meta(provider, model)
+    try:
+        priority = max(1, int(meta.get("priority") or 99))
+    except (TypeError, ValueError):
+        priority = 99
+    quality = 0.0 if priority == 99 else max(-8.0, 20.0 - (priority - 1) * 4.0)
+    tier = meta.get("tier") or provider.get("tier") or "standard"
+    tier_score = (_TIER_SCORE.get(difficulty) or {}).get(tier, 0.0)
+    price_score, price_reason = _price_score(pricing, model, difficulty)
+    dim = task_dimension(task_type, role)
+    strengths = provider.get("strengths") if isinstance(provider.get("strengths"), list) else []
+    strength_score = 10.0 if dim in strengths else 0.0
+    if difficulty == "easy":
+        quality *= 0.25
+    elif difficulty != "hard":
+        # 普通任务兼顾质量、成本与能力匹配；是否真的重排由调用方决定，
+        # 因而手工链仍可保持原顺序，自动推荐则能使用这组平衡分。
+        quality *= 0.65
+    vision_score = 0.0
+    if dim == "vision":
+        vision_score = 24.0 if meta.get("image_in") else -24.0
+    total = quality + tier_score + price_score + strength_score + vision_score
+    reason = ("质量 %+.1f，档位 %s %+.1f，%s，能力 %s %+.1f"
+              % (quality, tier, tier_score, price_reason, dim,
+                 strength_score + vision_score))
+    return round(total, 2), reason
+
+
+def rank_model_entries(entries, providers, pricing, difficulty,
+                       task_type="", role="", force=False):
+    """稳定排序模型链并返回脱敏决策明细；default 难度保持人工顺序。"""
+    rows = []
+    for index, entry in enumerate(entries or []):
+        score, reason = score_model_entry(
+            entry, providers, pricing, difficulty, task_type, role)
+        rows.append((score, index, entry, reason))
+    if difficulty in ("easy", "hard") or force:
+        rows.sort(key=lambda row: (-row[0], row[1]))
+    ranked = [row[2] for row in rows]
+    decisions = [{"provider_id": row[2].get("provider_id") or "",
+                  "provider": (row[2].get("provider") or {}).get("name") or "",
+                  "model": row[2].get("model") or "",
+                  "score": row[0], "reason": row[3]}
+                 for row in rows]
+    return ranked, decisions

package/app/core/flows.py

@@ -187,6 +187,11 @@ def _apply_overrides(base, ov):
                 f["rounds"] = max(1, min(5, int(v)))
             except Exception:
                 pass
+        elif k == "best_of":
+            try:
+                f["best_of"] = max(1, min(3, int(v)))
+            except Exception:
+                pass
         elif k in ("manuscript", "verify_command"):
             s = re.sub(r"[\\/]+", "_", str(v or "")).strip()
             s = re.sub(r"\.{2,}", "_", s).lstrip(".")