multicc 0.1.0__py3-none-any.whl

multicc-0.1.0.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.1
+Name: multicc
+Version: 0.1.0
+Summary: 多智能体任务编排器：把 prompt 拆给 Claude Code 与 Codex 执行，实时输出思维链/工具调用/交互/审批，支持中途注入
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License: MIT
+
+# tasker — 多智能体任务编排器（claude code × codex）
+ 
+ 输入一个目标，由 LLM 把它拆成**有依赖关系的子任务**，分派给 **Claude Code** 和 **Codex** 并行/串行执行；在 CLI 里**实时流式输出两者的完整思维链、工具调用、交互与审批请求**，并且你可以随时打字**继续提要求、中途修改、批准/拒绝**。
+ 
+ > 主目标平台：**macOS**。Windows/Linux 也可运行（headless 采集相同），但 pty 交互 attach 仅 macOS/Linux 原生支持。
+ 
+ ---
+ 
+ ## 特性
+ 
+ | 能力 | 说明 |
+ |---|---|
+ | 🧠 完整思维链 | Claude 的 `thinking` 块、Codex 的 `reasoning` 逐条实时打印（`--think full/head/off`） |
+ | 🔧 工具调用 | `tool_use`（工具名 + 参数 JSON）与 `tool_result`（stdout/stderr/是否报错） |
+ | 🔁 交互事件 | 子代理启动/进度/通知、任务轮次 |
+ | 🛡️ 审批请求 | 权限拒绝、`permission_request`/`permission_result` 实时浮现；`approval` 策略可 auto/log/ask |
+ | 💬 中途修改 | 运行中 `@claude/@codex/@all <消息>` 实时注入（claude 为真·多轮注入；codex 见下方限制） |
+ | 🎯 依赖编排 | LLM 拆出依赖图 → 分层并发；上游输出自动作为下游上下文 |
+ | 🧪 零依赖 | 纯 Python 标准库；`--mock` 无需任何 CLI/API key 即可演示全流程 |
+ | 📋 报告 | 可选 `--report` 落一份完整 Markdown 轨迹 |
+ 
+ ---
+ 
+ ## 安装
+ 
+ ```bash
+ # 1) 准备两个执行器（macOS）
+ claude                 # Claude Code CLI（本工具直接调用）
+ npm install -g @openai/codex   # Codex CLI（可选，未装时 codex 任务会失败/可先用 --mock）
+ 
+ # 2) 安装 tasker（命令名 tasker，PyPI 包名 multicc）
+ pip install multicc                    # 从 PyPI（需联网）
+ # 或离线：源码机 python scripts/build_wheel.py 得到 .whl 后 pip install <whl>
+ # 或源码直接跑：python tasker_cli.py
+ 
+ tasker verify-config     # 检查环境
+ 
+ # 3) 配置（可选项，见下方"配置"）
+ tasker init && $EDITOR config.json
+ ```
+ 
+ Python ≥ 3.9，无第三方依赖。完整打包 / 发布说明见 [RELEASE.md](RELEASE.md)。
+ 
+ ---
+ 
+ ## 快速开始
+ 
+ ```bash
+ # 真实运行（LLM 拆分 → claude/codex 执行 → CLI 实时输出）
+ python -m tasker run "写一个 Python CLI 工具，带子命令，并补上单元测试"
+ 
+ # 规则拆分（不用 LLM 也能跑，适合快速试）
+ python -m tasker run "实现一个斐波那契脚本" --plan-rules
+ 
+ # 无任何 CLI / API key 的纯演示
+ python -m tasker run "写一个 python 脚本并测试" --mock --think head
+ 
+ # 只打印计划
+ python -m tasker plan "重构这个项目" --json
+ 
+ # 附加到交互 TUI（macOS 原生，直接看真实审批弹窗）
+ python -m tasker attach claude "帮我初始化一个 Go 项目"
+ ```
+ 
+ ### 运行中随时输入
+ 
+ ```
+ @all <消息>          发给所有运行中的 agent
+ @claude <消息>       只发给 claude 执行的任务
+ @codex <消息>        只发给 codex 执行的任务
+ @t2 <消息>           发给指定任务
+ <裸文本>              等同 @all <文本>
+ :allow [<id>]        批准最近/指定审批请求
+ :deny  [<id>]        拒绝最近/指定审批请求
+ :done  [<taskid>]    手动收尾任务（关闭其 stdin 让进程退出）
+ :status              各任务进度（思考/工具/审批/注入计数）
+ :plan                重打计划
+ :quit                终止全部并退出
+ ```
+ 
+ > claude 子任务是**真·实时多轮**：注入的消息写入其 `stream-json` stdin，下一轮即被采纳（已实测：任务执行到一半注入"第二行改成 xxx"，最终产物按修改后内容产出）。
+ 
+ ---
+ 
+ ## 架构
+ 
+ ```
+ prompt
+   │  LLM API（anthropic / openai 兼容）
+   ▼
+ planner ──► Plan {tasks[], depends_on[], executor: claude|codex}
+   │            │  (规则拆分 plan_with_rules 作为无 key 回退)
+   ▼
+ scheduler（按依赖分层，max_parallel 并发）
+   ├─► ClaudeRunner ─► claude -p --output-format stream-json --verbose --input-format stream-json
+   │        │             stdin 保持打开 → @all/@claude 实时注入
+   │        ▼
+   │     事件流: thinking / tool_use / tool_result / task_* / result / permission_denials
+   ├─► CodexRunner ─► codex exec --json --full-trace
+   │        │             approval_request / tool_call / reasoning / completed
+   │        ▼
+   └─► 每个事件 → LiveTui 实时打印 + 写入 workspaces/<run>/<task>.events.jsonl
+             │
+             ▼
+       用户在终端输入 → 输入线程 → 路由给对应 runner
+ ```
+ 
+ 事件模型（`tasker/models.py`）：
+ `thinking` `text` `tool_use` `tool_result` `permission_request` `permission_result` `user_message` `interaction` `system` `error` `result` `raw`
+ 
+ 文件结构：
+ 
+ ```
+ tasker/
+   main.py          CLI 入口（run / plan / attach / verify-config / init）
+   scheduler.py     依赖分层、并发、用户输入路由、审批策略接线
+   planner.py       LLM 拆分 + 规则回退 + 依赖校验/环检测
+   claude_runner.py Claude 事件采集 + stdin 实时注入 + 完成判定
+   codex_runner.py  Codex 事件采集
+   live.py          LiveTui：实时打印 + 后台输入线程 + 指令解析
+   approvals.py     审批策略（auto / log / ask_console）
+   ptty.py          pty attach（macOS/Linux，真实审批交互）
+   llm.py / config.py / spawn.py / models.py / console.py / report.py / mock_runner.py
+ ```
+ 
+ ---
+ 
+ ## 配置（config.json）
+ 
+ | 段 | 键 | 默认 | 说明 |
+ |---|---|---|---|
+ | `llm` | `provider` | `anthropic` | 拆分用 LLM；`openai` 可接任意 OpenAI 兼容接口（DeepSeek/Ollama/网关） |
+ | `llm` | `base_url` | `""` | 兼容接口地址，如 `https://api.deepseek.com/v1` |
+ | `llm` | `api_key_env` | `ANTHROPIC_API_KEY` | 从该环境变量取 key |
+ | `llm` | `model` | `claude-sonnet-5` | 拆分模型 |
+ | `claude` | `permission_mode` | `acceptEdits` | headless 下自动允许工作区内编辑；要全自主（含 Bash）改 `bypassPermissions` |
+ | `claude` | `allowed_tools` | `[]` | 预授权工具白名单 |
+ | `claude` | `completion_idle` | `5.0` | 最终 result 后无活动秒数 → 关闭 stdin 收尾 |
+ | `codex` | `sandbox` | `workspace-write` | `read-only` / `workspace-write` / `danger-full-access` |
+ | `codex` | `auto_approve` | `false` | 传 `--auto-approve` 给 codex exec |
+ | `approval` | `mode` | `auto` | `auto` / `log` / `ask_console` |
+ | `approval` | `default_allow` | `true` | auto 模式的默认决定 |
+ | — | `max_parallel` | `2` | 同层并发数 |
+ | — | `timeout_per_task` | `900` | 单任务超时 |
+ 
+ ---
+ 
+ ## macOS 行为说明（重点）
+ 
+ - **进程启动**：macOS 上 `claude`/`codex` 是 POSIX 二进制或 `#!/bin/sh` shim，`spawn.py` 直接用 `shutil.which` 解析后 `Popen`，无需 `.cmd` 兼容层（Windows 的 `.cmd` 已额外处理）。
+ - **交互 attach**：`python -m tasker attach claude|codex` 用 `os.forkpty` 起交互式 TUI 并原样转发到你终端 —— 你能看到**真实的审批弹窗**并直接输入 `y/n` 回答。这是 headless 拿不到的那部分交互（claude -p / codex exec 无 TTY 不弹窗）。
+ - **编码**：全程 UTF-8；macOS 终端默认 UTF-8，中文/emoji 无碍。
+ - **权限**：headless 下 claude 的写文件/命令会走策略判定，拒绝会以 `tool_result` 拒由 + `result.permission_denials` 呈现（已实测）；需要"不问就干"请设 `permission_mode=bypassPermissions`（风险自负）。
+ - **SIGINT**：`Ctrl-C` 触发优雅中断（`KeyboardInterrupt` 路径）。
+ 
+ ## Codex 的已知限制
+ 
+ - `codex exec` 是**单轮非交互**模式，**不支持**像 claude 那样中途注入消息。`@codex` 注入会记录到交互日志，并在调度**依赖它的下一个子任务**时作为上下文携带（"下一轮注入"）。
+ - `codex exec --json` 会发 `approval_request` 事件（本工具会实时打印），但非交互下无法经 stdin 回答；真正的审批对话请用 `attach codex`。
+ - 未安装 codex 时，含 codex 的任务会失败并给出清晰报错；可用 `--mock` 或 `--plan-rules` 先体验。
+ 
+ ---
+ 
+ ## 常见问题
+ 
+ **任务拆分 LLM 报 401 / 网络错？**
+ `llm` 段用独立 API key。若你的 `ANTHROPIC_API_KEY` 是 Claude Code 网关专用 key，无法直接访问 api.anthropic.com —— 设 `llm.base_url` 指向你的网关，或换 `provider=openai` + DeepSeek/Ollama。任何失败都会自动回退到规则拆分。
+ 
+ **headless 下"审批请求"不弹窗？**
+ 这是 CLI 行为限制：权限弹窗只在交互 TTY 出现。headless 会直接给出工具执行/拒绝事件。要看并回答真实审批，用 `attach` 模式。
+ 
+ **运行卡住不结束？**
+ claude 发完最终结果不会自己退出（stdin 仍开）。完成判定：最终 `result` 后 `completion_idle` 秒无活动 → 关闭 stdin 收尾；可 `:done` 手动收尾。

multicc-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+tasker/__init__.py,sha256=VmIfCHtuPFKC0uBl4F5N4os-N1g639pL0JkVhThMrt0,280
+tasker/__main__.py,sha256=jKsDFN_oplUp1WjHZjL0oT1jzsRE_0icG-x1GDCZqdk,113
+tasker/approvals.py,sha256=9dMeI3lBi7ggpuJXV2Y_TXi4_gsiz4HM1zNz_WLH6ak,2796
+tasker/claude_runner.py,sha256=Saeo3t7Lt0hqjg3gvxyuV4vjP_SgoR2Cm_7_Kwecglg,12091
+tasker/codex_runner.py,sha256=aTApGY7D_XwODGRyJEMPjbycih80NK8bA5J5W7O9kwA,7712
+tasker/config.py,sha256=yHkS7MU9YQVUtLL6753CSEXBOdldYYIfjhCzBlAjb_U,6645
+tasker/console.py,sha256=sXyZdK0dPH1rycRSaKq3t9vaqCTbt1QhCB8bDRgqPkM,2666
+tasker/live.py,sha256=XbLPxo69g_O1g4oWB94KM8qL4CdOf3J6ifmrAfJwYGk,8232
+tasker/llm.py,sha256=DXPG-kDf4D2FNraHhovBfl-7SpGso2z5jTdze1meW0c,3182
+tasker/main.py,sha256=BXX7CvlMsjf22m9sE3vjQsYyGeVg_p2IM-R-mjkHUrU,8510
+tasker/mock_runner.py,sha256=SkcWDjBen6ut71it-3XucebIQacqpaLtK5c4woAi47w,4349
+tasker/models.py,sha256=QeFdzQnNF8c-WufEnYpLmkpc8qDtQdq4MKFKhZFxL0E,4360
+tasker/planner.py,sha256=lzSrqNzVAfFBBPNTwm6e-1lwiL2pN2d-xkInUtU5wOY,7232
+tasker/ptty.py,sha256=VmHYly-Az7kUHW4WWWWP5PsreKyCY81O_8N3l57lxAE,2916
+tasker/report.py,sha256=FaGWU1JTAgk9BEPQ0XmAgjVHe2ryycqKsAx0xm7VrWc,2268
+tasker/scheduler.py,sha256=sxr4_TJ2pvZuROerYxhvIgpdHobS5cq3ZgxgipN8uhU,11616
+tasker/spawn.py,sha256=D92VJQTxELCjVfOZSFnAkdaZwRyZfrX0_MJLFz4mWio,3768
+multicc-0.1.0.dist-info/METADATA,sha256=AvtPrWIymi2gLqA_26F9mlD4nJhwZHnE4IizDmkT6zQ,9335
+multicc-0.1.0.dist-info/WHEEL,sha256=K0kLJFydSWiP_0Rtow9wws1Z25Dj53aafJlcYqdHAsw,103
+multicc-0.1.0.dist-info/entry_points.txt,sha256=Owhe3dNFjk-NT9rh4ynoLhzUmgDFBc0Vwt-YU_-shjU,44
+multicc-0.1.0.dist-info/RECORD,,

multicc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: tasker.build_wheel (stdlib-only)
+Root-Is-Purelib: true
+Tag: py3-none-any

multicc-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tasker = tasker.main:main

tasker/__init__.py

@@ -0,0 +1,7 @@
+"""tasker —— 多智能体任务编排器。
+
+通过 LLM API 把用户 prompt 拆分为子任务，分派给 Claude Code 与 Codex 执行，
+并完整采集两者的"思维链 / 工具调用 / 交互 / 审批请求"事件，输出 Markdown 报告。
+"""
+
+__version__ = "0.1.0"

tasker/__main__.py

@@ -0,0 +1,5 @@
+"""python -m tasker 入口。"""
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tasker/approvals.py

@@ -0,0 +1,65 @@
+"""审批请求处理策略。
+
+headless 模式下各 CLI 对审批的表现不同：
+- claude -p：权限弹窗只在交互 TTY 出现；headless 下工具按 permission_mode 自动允许/拒绝，
+  我们把拒绝事件（tool_result / result.permission_denials）采集上报，必要时回注一条用户消息
+  告知模型"用户已批准，请继续"。
+- codex exec --json：会在 stdout 发 approval_request 事件，但非交互下无法经 stdin 回答；
+  auto_approve 由 --auto-approve 开关控制。
+真正的"人点批准/拒绝"交互请用 ptty attach 模式（macOS 原生支持）。
+"""
+from __future__ import annotations
+
+import time
+
+from .config import ApprovalConfig
+from .models import Event, TaskRun
+
+MODES = ("auto", "log", "ask_console")
+
+
+class ApprovalPolicy:
+    def __init__(self, cfg: ApprovalConfig, on_decision=None):
+        self.cfg = cfg
+        self.on_decision = on_decision
+        self.pending: dict[str, dict] = {}  # id -> {"run": TaskRun, "event": Event}
+
+    def handle(self, run: TaskRun, event: Event, emit, send_msg):
+        """处理一条 permission_request 事件。emit: (run, Event) 回调；send_msg: 回注消息函数。"""
+        req_id = str(event.data.get("id") or event.data.get("tool_use_id") or time.time())
+        mode = self.cfg.mode
+        self.pending[req_id] = {"run": run, "event": event, "ts": time.time()}
+
+        if mode == "auto":
+            allowed = self.cfg.default_allow
+            self._decide(req_id, allowed, run, event, emit, send_msg)
+        elif mode == "ask_console":
+            # 在 CLI 里已实时展示，等待用户 :allow / :deny
+            return
+        else:  # log
+            return
+
+    def decide(self, req_id: str, allowed: bool, emit, send_msg) -> bool:
+        """由用户指令 :allow/:deny 触发。"""
+        item = self.pending.get(req_id)
+        if item is None:
+            # 没有登记的请求：允许对所有运行中 runner 注入"用户决定"消息
+            return False
+        self._decide(req_id, allowed, item["run"], item["event"], emit, send_msg)
+        return True
+
+    def _decide(self, req_id, allowed, run, event, emit, send_msg) -> None:
+        note = "批准" if allowed else "拒绝"
+        emit(
+            run,
+            Event(
+                kind="permission_result",
+                source=run.task.executor,
+                text=f"{note}请求 {req_id}",
+                data={"allowed": allowed, "id": req_id},
+            ),
+        )
+        if send_msg:
+            guidance = "用户已批准该工具请求，如适用请继续执行。" if allowed else "用户已拒绝该请求，请换一种安全方式继续。"
+            send_msg(f"[审批反馈] {guidance}（{event.text}）")
+        self.pending.pop(req_id, None)

tasker/claude_runner.py

@@ -0,0 +1,271 @@
+"""Claude Code 采集器。
+
+headless 方式：claude -p --output-format stream-json --verbose --input-format stream-json
+- 从 stdout 逐行解析事件：thinking（思维链）、tool_use、tool_result、task 事件、result。
+- stdin 保持打开：send_message() 以 stream-json 用户消息实时注入，实现"中途修改/继续要求"。
+- 权限相关：headless 下权限弹窗不触发（交互 TTY 才有），工具执行/拒绝会体现为
+  tool_result 与 result.permission_denials，一并采集。
+"""
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+
+from .config import Config
+from .models import Event, TaskRun
+from .spawn import ProcChannel, resolve_binary, start_process
+
+
+class ClaudeRunner:
+    source = "claude"
+
+    def __init__(self, cfg: Config, run: TaskRun, workdir: str, on_event, prompt: str):
+        self.cfg = cfg
+        self.run = run
+        self.workdir = workdir
+        self.on_event = on_event
+        self.prompt = prompt
+        self.channel: ProcChannel | None = None
+        self._tool_names: dict[str, str] = {}
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._interactions: list[str] = []
+        # claude 发出 result 后不会自己退出（stdin 仍开），需要 settle 后关闭 stdin
+        self._result_ts: float | None = None
+        self._injection_ts: float | None = None
+        self._last_event_ts: float = time.time()
+        self._settle = float(getattr(cfg.claude, "completion_idle", 5.0))
+
+    # ---------- 完成判定 ----------
+    def is_done(self) -> bool:
+        if not self.is_alive():
+            return True
+        if self._result_ts is None:
+            return False
+        ref = max(self._result_ts, self._injection_ts or 0)
+        now = time.time()
+        # 结果之后：既无更新的注入，也无任何 claude 活动，持续 settle 秒 → 认为子任务完成
+        return (now - ref) > self._settle and (now - self._last_event_ts) > self._settle
+
+    def finalize(self) -> None:
+        """收到最终 result 后：关闭 stdin 让 claude 自然退出，等待一小段，必要时终止。"""
+        if not self.channel or not self.channel.is_alive():
+            return
+        self.channel.close_stdin()
+        try:
+            self.channel.proc.wait(timeout=8)
+        except Exception:
+            self.channel.stop()
+
+    # ---------- 生命周期 ----------
+    def build_args(self) -> list[str]:
+        c = self.cfg.claude
+        args = [resolve_binary(c.binary), "-p", "--output-format", "stream-json", "--verbose", "--input-format", "stream-json"]
+        if c.model:
+            args += ["--model", c.model]
+        if c.permission_mode and c.permission_mode != "default":
+            args += ["--permission-mode", c.permission_mode]
+        if c.allowed_tools:
+            args += ["--allowedTools", ",".join(c.allowed_tools)]
+        if c.disallowed_tools:
+            args += ["--disallowedTools", ",".join(c.disallowed_tools)]
+        args += c.extra_args
+        return args
+
+    def _sys_note(self) -> str:
+        return (
+            "你是 tasker 多智能体编排中的一个子任务 worker。当前工作目录即任务目录。\n"
+            "协作提示：编排器可能在运行中向你注入后续要求（用户中途修改/追问），收到后请按新要求调整再继续。"
+        )
+
+    def start(self) -> ProcChannel:
+        self.run.started_at = time.time()
+        args = self.build_args()
+        extra = ["--append-system-prompt", self._sys_note()]
+        self.channel = start_process(args + extra, workdir=self.workdir, name=f"claude-{self.run.task.id}")
+        # 初始用户消息（stream-json）
+        first = self._user_msg_json(self.prompt)
+        self.channel.write(first + "\n")
+        self._thread = threading.Thread(target=self._pump, daemon=True, name=f"claude-{self.run.task.id}")
+        self._thread.start()
+        return self.channel
+
+    # ---------- 实时注入 ----------
+    def send_message(self, text: str) -> bool:
+        if not self.channel or not self.channel.is_alive():
+            return False
+        ok = self.channel.write(self._user_msg_json(text) + "\n")
+        if ok:
+            self._interactions.append(text)
+            self._injection_ts = time.time()
+            self._emit(Event(kind="user_message", source=self.source, text=text))
+        return ok
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self.channel:
+            self.channel.stop()
+
+    def is_alive(self) -> bool:
+        return bool(self.channel and self.channel.is_alive())
+
+    @staticmethod
+    def _user_msg_json(text: str) -> str:
+        return json.dumps(
+            {"type": "user", "message": {"role": "user", "content": [{"type": "text", "text": text}]}},
+            ensure_ascii=False,
+        )
+
+    # ---------- 事件泵 ----------
+    def _emit(self, event: Event) -> None:
+        self._last_event_ts = time.time()
+        self.run.events.append(event)
+        self.on_event(self.run, event)
+
+    def _pump(self) -> None:
+        ch = self.channel
+        if not ch:
+            return
+        try:
+            while not self._stop.is_set():
+                line = ch.next_line(timeout=0.2)
+                if line is None:
+                    if not ch.is_alive():
+                        break
+                    continue
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    data = json.loads(line)
+                except json.JSONDecodeError:
+                    self._emit(Event(kind="raw", source=self.source, text=line[:2000]))
+                    continue
+                try:
+                    self._handle(data)
+                except Exception as e:  # noqa: BLE001 —— 单条事件解析失败不打断整个泵线程
+                    self._emit(Event(kind="error", source=self.source, text=f"事件解析失败: {e}"))
+        finally:
+            self.run.ended_at = time.time()
+
+    def _handle(self, data: dict) -> None:
+        t = data.get("type")
+        if t == "system":
+            sub = data.get("subtype", "")
+            if sub == "init":
+                self.run.exit_code = 0
+                self._emit(
+                    Event(
+                        kind="system",
+                        source=self.source,
+                        text=f"会话初始化 session_id={data.get('session_id','')[:8]}… cwd={data.get('cwd','')}",
+                        data={"session_id": data.get("session_id")},
+                    )
+                )
+            elif sub == "thinking_tokens":
+                pass  # token 计数噪音，忽略
+            elif sub in ("task_started", "task_progress", "task_notification", "interrupt_*"):
+                self._emit(
+                    Event(
+                        kind="interaction",
+                        source=self.source,
+                        text=f"{sub}: {data.get('description','')}",
+                        data={"task_id": data.get("task_id"), "tool_use_id": data.get("tool_use_id"), "subtype": sub},
+                    )
+                )
+            else:
+                self._emit(Event(kind="system", source=self.source, text=f"{sub} {data.get('description','')}", data=data))
+        elif t == "assistant":
+            msg = data.get("message", {})
+            for block in msg.get("content", []):
+                btype = block.get("type")
+                if btype == "thinking":
+                    self._emit(
+                        Event(
+                            kind="thinking",
+                            source=self.source,
+                            text=str(block.get("thinking", "")),
+                            data={"signature": block.get("signature")},
+                        )
+                    )
+                elif btype == "redacted_thinking":
+                    self._emit(Event(kind="thinking", source=self.source, text="[redacted thinking]"))
+                elif btype == "tool_use":
+                    name = block.get("name", "?")
+                    tid = block.get("id")
+                    if tid:
+                        self._tool_names[tid] = name
+                    self._emit(
+                        Event(
+                            kind="tool_use",
+                            source=self.source,
+                            text=name,
+                            data={"tool": name, "input": block.get("input", {}), "id": tid},
+                        )
+                    )
+                elif btype == "text":
+                    self._emit(Event(kind="text", source=self.source, text=str(block.get("text", ""))))
+        elif t == "user":
+            # 可能是 tool_result 回灌，或子代理消息
+            msg = data.get("message", {})
+            content = msg.get("content", [])
+            for block in content if isinstance(content, list) else [content]:
+                if not isinstance(block, dict):
+                    continue
+                if block.get("type") == "tool_result":
+                    name = self._tool_names.get(str(block.get("tool_use_id")), "?")
+                    result_text = block.get("content", "")
+                    if not isinstance(result_text, str):
+                        result_text = json.dumps(result_text, ensure_ascii=False, default=str)
+                    raw_extra = data.get("tool_use_result", {})
+                    extra = raw_extra if isinstance(raw_extra, dict) else {}
+                    self._emit(
+                        Event(
+                            kind="tool_result",
+                            source=self.source,
+                            text=result_text,
+                            data={
+                                "tool": name,
+                                "is_error": bool(block.get("is_error", extra.get("is_error", False))),
+                                "stdout": extra.get("stdout", "") if isinstance(extra.get("stdout"), str) else json.dumps(extra.get("stdout", ""), ensure_ascii=False, default=str),
+                                "stderr": extra.get("stderr", "") if isinstance(extra.get("stderr"), str) else json.dumps(extra.get("stderr", ""), ensure_ascii=False, default=str),
+                                "interrupted": bool(extra.get("interrupted", False)),
+                                "tool_use_id": block.get("tool_use_id"),
+                            },
+                        )
+                    )
+                elif block.get("type") == "text":
+                    self._emit(Event(kind="text", source=self.source, text=str(block.get("text", ""))))
+        elif t == "result":
+            self._result_ts = time.time()
+            self.run.output = str(data.get("result", ""))
+            self.run.exit_code = 0 if not data.get("is_error") else data.get("error")
+            self.run.cost_usd = float(data.get("total_cost_usd") or 0.0)
+            denials = data.get("permission_denials") or []
+            if denials:
+                for d in denials:
+                    self._emit(
+                        Event(
+                            kind="permission_result",
+                            source=self.source,
+                            text=str(d.get("message", "") or d),
+                            data={"allowed": False, "detail": d},
+                        )
+                    )
+            self._emit(
+                Event(
+                    kind="result",
+                    source=self.source,
+                    text=self.run.output,
+                    data={
+                        "stop_reason": data.get("stop_reason"),
+                        "terminal_reason": data.get("terminal_reason"),
+                        "cost_usd": self.run.cost_usd,
+                        "permission_denials": len(denials),
+                    },
+                )
+            )
+        else:
+            self._emit(Event(kind="raw", source=self.source, text=json.dumps(data, ensure_ascii=False)[:2000]))