@omnicrawl/cli-win32-ia32 0.2.8 → 0.4.0

package/host/rust/assets/config-templates/decision_models.example.toml

@@ -16,7 +16,7 @@ name = "Jev 主渠道"
 # 请求方式：
 #   jev             —— Jev 原生接口，POST {base_url}/v1/decide，state + questions 直接进请求体。
 #   chat_completions —— OpenAI 兼容接口，POST {base_url}/chat/completions，
-#                      base_url 与 [image_gen] / [tts_api] 同口径（填到 /v1）；
+#                      base_url 与 [image_gen] 同口径（填到 /v1）；
 #                      同一份 state + questions 作为 user 消息发出，从返回内容里解析 answers。
 #   onejev          —— 本机自部署的 OneJev 服务，POST {base_url}/v1/systemone，
 #                      请求与响应形状与 jev 相同；base_url 指向本地服务（见下方 [local]）。
@@ -29,6 +29,10 @@ api_key = ""
 api_key_env = "JEV_API_KEY"
 # 决策模型：jev-latest 跟随最新版本；生产环境建议钉死版本（如 jev-1.13.0）。
 model = "jev-latest"
+# 请求失败后的重试次数（不含首次请求）：连接失败、超时与上游 5xx 按 0.2s→0.4s→0.8s（封顶 2s）
+# 退避重试这么多次；4xx 不重试（那是请求本身的问题），读不到可用答案也不重试（不猜、不编）。
+# 一次决策在回合路径上同步等待，因此次数要有界（上限 10）；0 表示不重试。
+retry_count = 3
 enabled = true
 
 # 决策模型的功能开关。开关关闭时相关功能走原路径（当前即对话模型审查与本地排序检索）。
@@ -47,10 +51,32 @@ memory_search_rerank = false
 # 知识库检索使用决策模型排序：对 kb_search 同理，候选描述用标题、路径与摘要。
 kb_search_rerank = false
 
+# Skill 检索使用决策模型排序：开启后 skill_search 带关键词检索时先取更宽的候选池（最多 20 条），
+# 再让决策模型按相关程度排序，按各候选项的置信度降序返回，条数仍按调用方给的 max_results。
+# 不带关键词（按作用域列出全部）时没有「相关度」可判，不送审。决策服务不可用时回退本地排序，
+# 检索工具不会因此失败。
+skill_search_rerank = false
+
+# 联网搜索使用决策模型排序：开启后 web_search 对每一路渠道结果单独送审——本地先按关键词
+# 覆盖度圈出该路前 10 条，交决策模型按相关度排序后每路保留前 5 条。engine=mixed 时每路各自
+# 排序、各自最多 5 条，因此返回总量随渠道数增长（N 路 × 5 条），没有固定总量上限；只有调用方
+# 显式给了 max_results 才收窄总数。决策服务不可用时回退本地顺序，搜索不会因此失败。
+web_search_rerank = false
+
+# 联网搜索使用向量模型排序：与上一项并行，各自读自己的开关。它是唯一画在「向量模型」
+# 设置页顶部的开关（其余开关都在「结构化决策模型」页），配置仍在本段。开启后用「向量模型」设置里
+# 配置的渠道把查询与每条候选都算成向量，按余弦相似度给该路结果排序，每路仍保留前 5 条；
+# 判定条数上限的口径与 web_search_rerank 一致。两项都开启时**向量优先**：向量不可用
+# （未配渠道、无凭据、请求失败）才回退决策模型排序；决策模型也不可用时回退本地关键词排序，
+# 搜索不会因此失败。向量通路不依赖决策模型服务，因此不必先配决策渠道。
+web_search_embedding_rerank = false
+
 # 提问由决策模型自动作答：开启后模型调用 ask_user 且带选项时，不再弹面板等你作答，
 # 而是把提问正文、你本回合的请求与本回合已有的顾问答复交给决策模型，让它选最符合
-# 你意图的一项。没有选项的提问（自由问答）照旧交给你。决策服务不可用时回退到人工
-# 提问，不会替你瞎猜；自动作答会在会话流里留一条提示。
+# 你意图的一项。候选项末尾固定带一项「我有自己的想法...」：需要你自己填写答案时决策
+# 模型会选它，提问就退回面板（由你选或输入自己的回答）。没有选项的提问（自由问答）
+# 照旧交给你。决策服务不可用时回退到人工提问，不会替你瞎猜；自动作答会在会话流里
+# 留一条提示。
 ask_user_custody = false
 
 # 旧一轮工具调用按需淘汰（先标注-后压缩）：只裁决「刚变老」的那一批（Agent 又推进了一批
@@ -72,6 +98,34 @@ ask_user_custody = false
 # 重启后按同一份投影重建同一份上下文。
 tool_call_prune = false
 
+# 新提问自动建议工具：开启后，你每发一条新提问，宿主先把**这一条提问的正文**（不带历史）
+# 与一份「已启用工具」的清单交给决策模型，问它「本次该用哪些工具」。每个工具一个是否题，
+# 概率 ≥0.5 进建议名单、<0.5 排除；另有最后一个兜底判定——本条属于普通对话、寒暄或无从
+# 判断的异常任务时，整份建议作废（不插入任何内容）。名单非空时在提问尾部追加一行
+# 「当前请求建议调用tool：a、b。」再发给模型。
+#
+# 清单就是本机工具表里全部已启用的工具（每项为工具名 + 描述首句，截断到 24 字），不做人工
+# 取舍：关掉的工具与当前没有运行期的工具（语音合成、顾问、Windows 组）本来就不在表里。
+# 该用专用工具还是顺手用泛化工具，由决策模型按选择要求判断——子代理、生图、语音、桌面
+# 操作这类专用工具贴合任务特殊性；读文件、搜代码、执行命令、记待办这类通用工具几乎每轮
+# 都能顺手用一下，除非本次任务明确围绕它展开，否则判为用不到。决策服务不可用（缺渠道/凭据、
+# 超时、响应不可解析）时按「本次无建议」处理，提问原文照发，不会挡住你的输入。
+tool_suggestion = false
+
+# 新提问自动建议子代理：与上面的 `tool_suggestion` 形状相同、互相独立，可单开也可同时开。
+# 区别在候选清单：这里送审的是**本机可调度的子代理角色**（每项为角色名 + 角色描述首句，
+# 截断到 24 字），与 `subagent` 工具的参数枚举同源，内核不能调度的角色不会进审。
+# 判定同样是每个角色一个是否题 + 一个兜底判定（本条是否属于无需任何子代理的普通对话），
+# 概率阈值都是 0.5。名单非空时在提问尾部追加一行「当前请求建议使用子代理：explore、plan。」。
+#
+# 子代理个个都是一次带独立上下文的子回合，开销明显高于主模型自己动手，因此判定要求特别
+# 强调：只有能拆成相互独立、可并行推进的子任务，或需要隔离视角核查与隔离改动时才算用得到；
+# 单步问答、小改动、串行依赖的活一律判为用不到。
+#
+# 两类同时开启时，两条请求**并发发起**，总耗时取两者的较大者而不是相加；任一失败只少一行。
+# 决策服务不可用时同样按「本次无建议」处理，提问原文照发。
+subagent_suggestion = false
+
 # 决策 REST 接口：把决策能力暴露给本机其它程序（CLI 工具、Skill、外部脚本），
 # 它们不必经主模型就能拿到决策结果。大脑（主模型）负责规划，小脑（决策模型）负责
 # 快速判定，两者通过这个接口协同。
@@ -91,14 +145,15 @@ tool_call_prune = false
 [api]
 enabled = false
 host = "127.0.0.1"
-# 端口：与本地 API（8765）和自部署的 OneJev 服务（8766）都错开。
+# 端口：与本地 API（8765）错开。
 port = 8767
 
 # 自部署（OneJev）：在本机跑一份决策模型，不依赖云端服务。
 #
 # 官方发布 0.8B / 4B / 9B / 27B / 27B-FP8 五档（Hugging Face 的 OmniJev/OneJev-*），
-# 由本机 Python 服务 `qev serve` 提供 TypeSafe 兼容接口。设置面板的「结构化决策模型」页
-# 可以一键下载某一档、准备运行环境、启停本地服务，并把决策渠道切到自部署。
+# 由本机的判定 worker 直接驱动引擎，经命名管道（Windows）/ Unix socket 提供同一套判定——
+# 不经 TCP 与 HTTP。设置面板的「结构化决策模型」页可以一键下载某一档、准备运行环境、
+# 启停本地服务，并把决策渠道切到自部署。
 # 权重与虚拟环境都在 model_dir 下（默认 ~/.omnicrawl/onejev），不进工作区。
 [local]
 # 当前部署的尺寸：0.8B / 4B / 9B / 27B-FP8 / 27B。
@@ -113,5 +168,5 @@ model_dir = ""
 # 本机已有服务在跑（本机所有实例共用一份）就直接复用，不会重复启动；服务常驻，
 # 不随实例退出被回收，要停就在设置页点「停止服务」。
 auto_start = true
-# 启动后等待健康检查的上限（秒）：首次加载权重并捕获 CUDA 图，大尺寸会久一些。
+# 启动后等待服务就绪的上限（秒）：首次加载权重并捕获 CUDA 图，大尺寸会久一些。
 health_timeout_seconds = 600

package/host/rust/assets/config-templates/embedding_models.example.toml

@@ -0,0 +1,31 @@
+# OmniCrawl 向量模型配置（在设置面板「向量模型」页新建渠道后自动生成 embedding_models.toml）
+#
+# 向量模型把一段文本映射成一个定长浮点向量，记忆检索用它做语义召回：先把查询与
+# 候选记忆都换成向量，按余弦相似度排序，再与关键词规则分做倒数排名融合。
+#
+# 全部走云端 OpenAI 兼容接口（POST {base_url}/embeddings），不使用本地模型：
+# 本地推理要多一份模型文件与推理运行时，代价远高于收益。
+#
+# 未配置、未启用或缺凭据时，记忆检索直接退回纯关键词规则排序——这是刻意的兜底，
+# 不是错误：向量召回是纯加速项，不可用不该让检索失败。
+#
+# 密钥请用环境变量（api_key_env）；也可以直接写 api_key，但不要提交到版本库。
+version = 1
+
+# 默认使用的向量渠道 key；留空或指向不存在的渠道时取第一条启用的渠道。
+default_key = "openai-embedding"
+
+[channels.openai-embedding]
+name = "OpenAI 向量"
+# base_url 按 OpenAI 兼容口径填到 /v1，这里只追加 /embeddings。
+base_url = "https://api.openai.com/v1"
+api_key = ""
+api_key_env = "OPENAI_API_KEY"
+model = "text-embedding-3-small"
+# 期望维度；0 表示由服务端决定（不下发 dimensions 字段）。
+# 换模型或改维度后旧向量会自然失效（缓存键带渠道指纹）。
+dimensions = 0
+# 单次请求最多携带的文本条数；候选多时按此分批串行发送。
+batch_size = 64
+timeout_seconds = 30
+enabled = true

package/host/rust/assets/config-templates/subagents.example.toml

@@ -1,38 +1,37 @@
-# OmniCrawl 子代理设置模板（首次启动自动复制为 subagents.toml）
-# 子代理设置已从 config.toml 完全迁移到本文件；程序只读取 subagents.toml，
-# 不再回退读取 config.toml 的 [subagents] 段。
-version = 1
-
-# SubAgent 全局边界：默认关闭；普通角色仅只读，verify 还需单独显式启用。
-[subagents]
-enabled = false
-max_depth = 1
-max_concurrency = 2
-max_tasks_per_batch = 4
-default_timeout_seconds = 3600
-model_request_concurrency = 2
-allow_background = false
-# 仅开放已脱敏父公开上下文的 read_only/verify Fork；默认关闭。
-allow_fork = false
-allow_shared_workspace_writes = false
-allow_worktree = false
-allow_standard_agent = false
-enable_verify_agent = false
-verify_command_timeout_seconds = 120
-task_retention_minutes = 60
-result_summary_chars = 6000
-
-# 单独设置每个子代理使用的模型；key 必须与 Agent 定义名一致（如 explore/plan/verify）。
-# model 支持：models.toml key/alias、profile/model_id 或裸 model_id；
-# 缺省或写 inherit 表示沿用父模型（与任务级 model=inherit 语义一致）。
-[subagents.models.explore]
-# model = "default-chat"
-
-[subagents.models.plan]
-# model = "default-chat"
-
-[subagents.models.verify]
-# model = "default-chat"
-
-[subagents.models.general-purpose]
-# model = "default-chat"
+# OmniCrawl 子代理设置模板（首次启动自动复制为 subagents.toml）
+# 子代理设置已从 config.toml 完全迁移到本文件；程序只读取 subagents.toml，
+# 不再回退读取 config.toml 的 [subagents] 段。
+version = 1
+
+# SubAgent 全局边界：默认关闭；开启后三种角色的能力开关默认放开（verify / standard / worktree）。
+[subagents]
+enabled = false
+max_depth = 1
+default_timeout_seconds = 3600
+model_request_concurrency = 2
+# 保留以兼容既有配置；子代理已改为回合内同步串行执行，本项不再生效。
+allow_background = false
+# 仅开放已脱敏父公开上下文的 read_only/verify Fork；默认关闭。
+allow_fork = false
+allow_shared_workspace_writes = false
+allow_worktree = true
+allow_standard_agent = true
+enable_verify_agent = true
+verify_command_timeout_seconds = 120
+task_retention_minutes = 60
+result_summary_chars = 6000
+
+# 单独设置每个子代理使用的模型；key 必须与 Agent 定义名一致（如 explore/plan/verify）。
+# model 支持：models.toml key/alias、profile/model_id 或裸 model_id；
+# 缺省或写 inherit 表示沿用父模型（与任务级 model=inherit 语义一致）。
+[subagents.models.explore]
+# model = "default-chat"
+
+[subagents.models.plan]
+# model = "default-chat"
+
+[subagents.models.verify]
+# model = "default-chat"
+
+[subagents.models.general-purpose]
+# model = "default-chat"

package/host/rust/assets/extensions/onejev_worker.py

@@ -0,0 +1,293 @@
+"""OneJev 本地决策 worker：在命名管道（Windows）/ Unix socket 上提供 System One 判定。
+
+为什么不用 `qev serve`：官方那个服务经 uvicorn/FastAPI 暴露 HTTP，本机调用方因此要为
+一次纯内存判定多付一层 TCP + ASGI 中转。这个 worker 直接持有 `qev` 的引擎对象，
+请求从管道进来、答案从管道出去，中间只有一次 JSON 编解码。
+
+协议（NDJSON，一行一个 JSON 对象）：
+
+    请求   {"model": "...", "state": {...}, "questions": {...}}
+    成功   {"model": "...", "answers": {...}, "usage": {...}, "qev": {...}}
+    失败   {"error": "可读原因"}
+
+响应形状故意与 HTTP 端点一致，Rust 侧读答案的代码因此不必区分两种传输。
+
+服务是**本机共用**的常驻进程，由 OmniCrawl 宿主以脱离进程的方式拉起（见
+`omnicrawl-onejev` 的 `server` 模块）：加载权重、创建端点、打出就绪标记，之后一直服务；
+停止只能显式做（宿主按 PID 回收整棵进程树）。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import socket
+import sys
+import threading
+import time
+from pathlib import Path
+
+# 就绪标记：宿主按它认定「服务已经能接请求」（写进服务日志）。
+READY_MARKER = "[onejev] 服务就绪"
+# 单次连接的等待上限（秒）：客户端总是连上就发，静默超时说明对端已经不在了。
+CONNECTION_TIMEOUT_SECONDS = 60.0
+# 管道缓冲区：一次判定请求的 state 上限是 64k 字符级别，留一倍余量。
+PIPE_BUFFER_BYTES = 128 * 1024
+
+log = logging.getLogger("onejev.worker")
+
+
+class Decider:
+    """引擎 + 判定；串行化——一次前向独占前缀缓存，并发只会互相踩。"""
+
+    def __init__(self, engine, model_name: str) -> None:
+        self.engine = engine
+        self.model_name = model_name
+        self._lock = threading.Lock()
+
+    def answer(self, body: dict) -> dict:
+        from qev.schema import SystemOneRequest
+
+        request = SystemOneRequest.model_validate(body)
+        with self._lock:
+            response, meta = self.engine.decide(request)
+        response.model = self.model_name
+        payload = response.model_dump()
+        payload["qev"] = meta
+        return payload
+
+
+def _handle_connection(decider: Decider, read_line, write_line, close) -> None:
+    """一次连接 = 一次判定：读一行请求，回一行响应（成功或错误），然后收线。"""
+    try:
+        line = read_line()
+        if not line:
+            return
+        payload = decider.answer(json.loads(line))
+    except Exception as error:  # 请求不合法 / 引擎报错：回一行可读原因，不猜答案
+        log.warning("判定失败：%s", error)
+        message = str(error) or error.__class__.__name__
+        try:
+            write_line(json.dumps({"error": message}, ensure_ascii=False))
+        except Exception:
+            pass
+    else:
+        write_line(json.dumps(payload, ensure_ascii=False))
+    finally:
+        close()
+
+
+# --------------------------------------------------------------------------
+# Windows：命名管道
+# --------------------------------------------------------------------------
+
+
+def windows_pipe_io(endpoint: str, decider: Decider) -> None:
+    import ctypes
+    import ctypes.wintypes as wintypes
+    import msvcrt
+
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+
+    pipe_access_duplex = 0x00000003
+    pipe_type_byte = 0x00000000
+    pipe_readmode_byte = 0x00000000
+    pipe_wait = 0x00000000
+    pipe_unlimited_instances = 255
+    invalid_handle = wintypes.HANDLE(-1).value
+    error_pipe_connected = 535
+
+    kernel32.CreateNamedPipeW.restype = wintypes.HANDLE
+    kernel32.CreateNamedPipeW.argtypes = [
+        wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, wintypes.DWORD,
+        wintypes.DWORD, wintypes.DWORD, wintypes.DWORD, ctypes.c_void_p,
+    ]
+    kernel32.ConnectNamedPipe.restype = wintypes.BOOL
+    kernel32.ConnectNamedPipe.argtypes = [wintypes.HANDLE, ctypes.c_void_p]
+    kernel32.PeekNamedPipe.restype = wintypes.BOOL
+    kernel32.PeekNamedPipe.argtypes = [
+        wintypes.HANDLE, ctypes.c_void_p, wintypes.DWORD,
+        ctypes.POINTER(wintypes.DWORD), ctypes.POINTER(wintypes.DWORD), ctypes.POINTER(wintypes.DWORD),
+    ]
+    kernel32.CloseHandle.restype = wintypes.BOOL
+    kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+
+    def create_instance() -> int:
+        return kernel32.CreateNamedPipeW(
+            endpoint,
+            pipe_access_duplex,
+            pipe_type_byte | pipe_readmode_byte | pipe_wait,
+            pipe_unlimited_instances,
+            PIPE_BUFFER_BYTES,
+            PIPE_BUFFER_BYTES,
+            0,
+            None,
+        )
+
+    def serve_instance(handle: int) -> None:
+        fd = msvcrt.open_osfhandle(handle, os.O_RDWR | os.O_BINARY)
+        stream = os.fdopen(fd, "r+b", buffering=0)
+
+        def read_line() -> str:
+            buffer = bytearray()
+            deadline = time.monotonic() + CONNECTION_TIMEOUT_SECONDS
+            while b"\n" not in buffer:
+                available = wintypes.DWORD(0)
+                kernel32.PeekNamedPipe(
+                    wintypes.HANDLE(handle), None, 0, None, ctypes.byref(available), None
+                )
+                if available.value:
+                    chunk = stream.read(available.value)
+                    if not chunk:
+                        break
+                    buffer += chunk
+                    continue
+                if time.monotonic() > deadline:
+                    break
+                time.sleep(0.005)
+            return bytes(buffer).split(b"\n", 1)[0].decode("utf-8", "replace")
+
+        def write_line(text: str) -> None:
+            stream.write(text.encode("utf-8") + b"\n")
+
+        # 关闭 fd 即关闭 handle（`open_osfhandle` 把它交给了 fd）。
+        _handle_connection(decider, read_line, write_line, stream.close)
+
+    # 实例先建出来再报就绪：宿主看到标记时端点必须已经能被连上。
+    first = create_instance()
+    if first == invalid_handle:
+        raise SystemExit(f"创建命名管道失败：{ctypes.get_last_error()}（{endpoint}）")
+    print(f"{READY_MARKER} endpoint={endpoint}", flush=True)
+
+    pending = first
+    while True:
+        handle = pending
+        if not kernel32.ConnectNamedPipe(wintypes.HANDLE(handle), None):
+            error = ctypes.get_last_error()
+            # ERROR_PIPE_CONNECTED 说明客户端已经连上了这个实例，照旧交给服务线程。
+            if error != error_pipe_connected:
+                kernel32.CloseHandle(wintypes.HANDLE(handle))
+                pending = create_instance()
+                continue
+        # 一个实例只服务一个连接；下一个实例提前建好，客户端不会撞到「管道不存在」。
+        pending = create_instance()
+        threading.Thread(target=serve_instance, args=(handle,), daemon=True).start()
+
+
+# --------------------------------------------------------------------------
+# Unix：Unix domain socket（没有 TCP 端口，也没有 HTTP 中转）
+# --------------------------------------------------------------------------
+
+
+def unix_socket_io(endpoint: str, decider: Decider) -> None:
+    path = Path(endpoint)
+    if path.exists():
+        path.unlink()
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    server.bind(endpoint)
+    server.listen(64)
+    os.chmod(endpoint, 0o600)
+    print(f"{READY_MARKER} endpoint={endpoint}", flush=True)
+
+    def serve_connection(connection: socket.socket) -> None:
+        stream = connection.makefile("rwb", buffering=0)
+
+        def read_line() -> str:
+            connection.settimeout(CONNECTION_TIMEOUT_SECONDS)
+            line = stream.readline()
+            return line.decode("utf-8", "replace").rstrip("\n") if line else ""
+
+        def write_line(text: str) -> None:
+            stream.write(text.encode("utf-8") + b"\n")
+
+        def close() -> None:
+            try:
+                stream.close()
+            finally:
+                connection.close()
+
+        _handle_connection(decider, read_line, write_line, close)
+
+    while True:
+        connection, _ = server.accept()
+        threading.Thread(target=serve_connection, args=(connection,), daemon=True).start()
+
+
+# --------------------------------------------------------------------------
+# 引擎装配（与 `qev serve` 同口径，但不启 HTTP 服务）
+# --------------------------------------------------------------------------
+
+
+def build_engine(args: argparse.Namespace):
+    from qev.calibrate import Calibration
+    from qev.mm_engine import local_model_dir
+
+    model_path = local_model_dir(args.model)
+    local = Path(model_path) / "calibration.json"
+    calib_path = args.calibration or (str(local) if local.exists() else None)
+    calibration = Calibration.load(calib_path) if calib_path else None
+    if calib_path:
+        log.info("calibration: %s", calib_path)
+
+    config = json.loads((Path(model_path) / "config.json").read_text())
+    if args.multimodal or config.get("vision_config") is not None:
+        from qev.mm_engine import MMDecisionEngine
+
+        return MMDecisionEngine(
+            model_path,
+            device=args.device,
+            dtype=args.dtype,
+            calibration=calibration,
+            fork_mode=args.fork_mode,
+            head_dtype=args.head_dtype,
+            max_branch_tokens=args.max_branch_tokens,
+            max_request_tokens=args.max_request_tokens,
+            gpu_preprocess=not args.no_gpu_preprocess,
+            cuda_graphs=not args.no_cuda_graphs,
+        )
+    from qev.engine import DecisionEngine
+
+    return DecisionEngine(
+        model_path,
+        device=args.device,
+        dtype=args.dtype,
+        calibration=calibration,
+        fork_mode=args.fork_mode,
+        head_dtype=args.head_dtype,
+        max_branch_tokens=args.max_branch_tokens,
+        max_request_tokens=args.max_request_tokens,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="onejev_worker")
+    parser.add_argument("--model", required=True, help="本地权重目录（或 Hub id）")
+    parser.add_argument("--name", default=None, help="对外的模型名")
+    parser.add_argument("--endpoint", required=True, help="命名管道名或 Unix socket 路径")
+    parser.add_argument("--device", default="cuda")
+    parser.add_argument("--dtype", default="bfloat16")
+    parser.add_argument("--head-dtype", default="float32")
+    parser.add_argument("--fork-mode", default="auto")
+    parser.add_argument("--multimodal", action="store_true")
+    parser.add_argument("--no-cuda-graphs", action="store_true")
+    parser.add_argument("--no-gpu-preprocess", action="store_true")
+    parser.add_argument("--calibration", default=None)
+    parser.add_argument("--max-branch-tokens", type=int, default=32768)
+    parser.add_argument("--max-request-tokens", type=int, default=65536)
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s")
+
+    engine = build_engine(args)
+    decider = Decider(engine, args.name or Path(args.model).name)
+
+    if sys.platform == "win32":
+        windows_pipe_io(args.endpoint, decider)
+    else:
+        unix_socket_io(args.endpoint, decider)
+
+
+if __name__ == "__main__":
+    main()

package/host/rust/assets/templates/speaking-style.md

@@ -0,0 +1,13 @@
+# OmniCrawl 简洁回复模式
+
+你当前处于 **Speaking Style（简洁回复模式）**。目标是在不丢结论的前提下把回复压到最短。
+
+## 规则
+
+- 面向用户的回复最多十行（列表项、空行都计入），优先控制在三到五行。
+- 先给结论，再给必要依据；不复述需求，不写铺垫，不写总结段。
+- 默认不用标题、表格与代码块；必须给命令或代码时只保留关键行。
+- 只保留会改变用户决策的信息；过程细节、工具输出原文、探索记录一律不展开。
+- 需要用户决策时，问题占一行，选项各占一行。
+- 十行仍不足以表达时，保留结论与下一步，其余内容写进文件并只给路径。
+- 简洁只压缩表达，不省略风险、失败、未验证项等关键限定；不得为了简短而编造结论。

package/host/rust/assets/templates/subagents/computer-use.md

@@ -0,0 +1,75 @@
+---
+name: computer-use
+description: 在桌面窗口上执行点击、输入与拖拽，按截图判断下一步并回报阻塞点
+tools:
+  - windows_window
+  - windows_screenshot
+  - windows_input
+  - windows_control
+  - read_image
+  - list
+  - read
+model: inherit
+permissionMode: standard
+background: false
+isolation: shared
+skills: []
+mcpServers: []
+---
+
+你是 OmniCrawl 的桌面操作子 Agent。你通过截图观察屏幕，用鼠标与键盘完成父 Agent 交代的目标。
+
+## 一、坐标规则
+
+- 截图工具返回 `source_bounds`（截取区域）与 `image.width/height`（实际图片尺寸）。
+- `windows_input` 接受的是**桌面坐标**，即 `source_bounds` 坐标系里的像素。
+- 图片未缩放（`scaled: false`）：`x = source_bounds.left + 截图像素 x`，`y = source_bounds.top + 截图像素 y`。
+- 图片被缩放（`scaled: true`）：先按比例还原——
+  `x = source_bounds.left + 截图像素 x * source_bounds.width / image.width`，
+  `y = source_bounds.top + 截图像素 y * source_bounds.height / image.height`。
+- 一律使用工具返回的真实 `image.width/height` 计算，不要用你请求的 `max_dimension` 反推。
+- 本机进程是 DPI-unaware，截图与鼠标输入共用同一套虚拟化坐标，**不要**再乘任何缩放或 DPI 系数。
+
+## 二、动作选择
+
+- 能用 `windows_control` 语义定位的控件（按钮、输入框、菜单项），优先用它，不要猜坐标。
+- 只有语义定位失效时才退回坐标点击。
+- 点击后不要立刻截图：先做廉价校验（窗口标题变化、控件文本、剪贴板）。
+- 连着几步操作（点地址栏 → 输入网址 → 回车）用一次 `actions` 传动作数组，按顺序执行。
+- 浏览器前进后退用 `action=click` 配 `button=back` 或 `button=forward`，不要去点工具栏图标。
+
+## 三、截图纪律
+
+- `windows_input`、`windows_control`（除 `list`）、`windows_window` 的 `activate` 都会随结果带回一张操作后的画面（`screenshot` 字段 + 图片），核对效果直接看它，不要再调 `windows_screenshot`。
+- 只有在这张自带截图缺失（结果里只有 `screenshot_error`）或需要看别处画面时才截图，且优先截目标窗口，不要截整屏。
+- 必须截桌面时用 `target=desktop` 配上 `x`/`y`/`width`/`height` 裁剪到目标区域，别把整屏塞进上下文。
+- 不要对同一画面重复截图；确认画面确有变化后再截。
+- 同一坐标连续两次点击后画面仍无变化，判定为阻塞点，立即停下回报。
+
+## 四、长按与拖拽
+
+- 长按：`windows_input` 的 `action=click` 带 `hold_ms`。
+- 拖拽：`action=press` → `action=move` → `action=release`，中间必须有移动事件。
+- 任何 `press` 都必须配对 `release`；提前结束也要先 `release`。
+
+## 五、边界
+
+- 没有任何人工审核环节，破坏性操作（删除、卸载、关机、提交订单、发送消息）必须先停下，
+  把待确认的动作写进回报，由父 Agent 决定。
+- 不要操作与目标无关的窗口。
+- 不要输入疑似凭据的内容，也不要从屏幕上抄录密码、令牌。
+
+## 六、回报格式
+
+任务结束（完成、受阻或超时）时，用一段 JSON 收尾，不要输出其他内容：
+
+```json
+{
+  "status": "completed | blocked",
+  "summary": "一句话说明结果",
+  "obstacle": "status=blocked 时写阻塞原因，否则为空串",
+  "screenshots": ["最后一张截图路径"]
+}
+```
+
+`status=blocked` 表示需要父 Agent 决策或补充信息；不要在无计可施时反复重试同一动作。

package/host/rust/assets/templates/system_prompt.md

@@ -24,6 +24,10 @@ OmniCrawl 是一个能够长期处理本地项目任务的 Agent。
 - 写入前先搜索；填写 frontmatter（title、created、updated、project、tags、type note|meeting|decision|log|research|reference、status draft|done|archived）。文件应存放在 `projects/<project>/`、`topics/<topic>/` 或 `daily/YYYY/MM/` 下；绝不手动编辑 `INDEX.md`。
 - 不得写入凭据或个人敏感信息；笔记必须是 UTF-8 Markdown。不要使用知识库存储会话进度、项目技术事实或稳定用户偏好；不要将知识库与 `omnicrawl://docs/` 或工作区文件混淆。
 
+Skill 使用协议：
+- Skill 目录不注入上下文：需要时先用 `skill_search` 检索索引（`query` 写任务关键词，`scope` 取 all/project/user/enterprise/path 收窄范围），命中后用 `read` 打开结果里的 `location` 读正文，再按其中的流程执行。
+- Skill 目录常在 `~/.omnicrawl/skills/` 或 `.omnicrawl/skills/`（工作区之外），不要用 `find`、`grep` 去找 Skill。用户用 `/skill:<名>` 指定时，该 Skill 正文已在上下文里。
+
 Todo 规划协议：
 - 对于任何多步骤项目任务，先调用 `update_todos`，提交简洁、有序且具体的步骤列表，然后再检查或编辑文件。每完成一个重要步骤，就重新提交列表并将对应步骤的 `completed` 标记为 true；提交空列表表示清除计划。不要只用文字计划替代该工具调用。
 
@@ -57,7 +61,7 @@ omnicrawl文档（共 14 篇，均以 `omnicrawl://docs/<文件名>` 读取，
 - 顾问策略（零参数 `advisor` 工具、`[advisor]` 配置、`/advisor` 命令、设置面板「顾问设置」）：读取 `omnicrawl://docs/advisor_design.md`；实现位于 `rust/crates/omnicrawl-controllers/src/advisor.rs` 和 `rust/crates/omnicrawl-config/src/features/advisor.rs`。
 - 工具输出压缩（外接小模型压缩工具结果、`[tool_output_compression]` 配置、设置面板「工具输出压缩」）：读取 `omnicrawl://docs/tool_output_compression_design.md`；实现位于 `rust/crates/omnicrawl-controllers/src/compression.rs`。
 - AI 消息脱敏（可逆占位符、匹配引擎、序号注册表、流式还原、`[desensitization]` 配置、设置面板「消息脱敏」）：读取 `omnicrawl://docs/agent_gateway_desensitization_design.md`；实现位于 `rust/crates/omnicrawl-llm/src/desensitization/` 和 `rust/crates/omnicrawl-config/src/features/desensitization.rs`。
-- TTS 语音合成（MOSS-TTS-Nano ONNX CPU：配置、tts_synthesize 工具、CLI、语音克隆、模型下载）：读取 `omnicrawl://docs/TTS.md`；实现位于 `rust/crates/omnicrawl-tts/` 和 `rust/crates/omnicrawl-config/src/features/tts.rs`。
+- TTS 语音合成（Kokoro-82M ONNX CPU：配置、tts_synthesize 工具、CLI、音素化、模型下载）：读取 `omnicrawl://docs/TTS.md`；实现位于 `rust/crates/omnicrawl-tts/` 和 `rust/crates/omnicrawl-config/src/features/tts.rs`。
 - 决策接口（结构化决策模型的本地 REST 服务：启动、无鉴权的回环访问、decide/choice/rank/review 端点、常驻与复用、脱敏与安全边界）：读取 `omnicrawl://docs/decision_api.md`；实现位于 `rust/crates/omnicrawl-decision/` 和 `rust/crates/omnicrawl-config/src/features/decision_model.rs`。
 - FSAPP 接入（文件系统应用侧的接入约定）：读取 `omnicrawl://docs/FSAPP.md`。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnicrawl/cli-win32-ia32",
-  "version": "0.2.8",
+  "version": "0.4.0",
   "description": "OmniCrawl 平台包（Windows 32 位：内核 + 完整宿主）",
   "repository": {
     "type": "git",

package/version.json

@@ -1,10 +1,10 @@
 {
   "name": "@omnicrawl/cli-win32-ia32",
-  "version": "0.2.8",
+  "version": "0.4.0",
   "os": "win32",
   "cpu": "ia32",
   "kernelVersion": "0.0.1",
-  "hostVersion": "0.2.8",
+  "hostVersion": "0.4.0",
   "hostPlatform": "win32-ia32",
-  "builtAt": "2026-10-07T18:36:14.621Z"
+  "builtAt": "2026-10-26T00:04:07.745Z"
 }