Emit hook progress events

Author: SqlRush

docs/cc-100-roadmap.md

@@ -33,6 +33,8 @@
 | M10 Agents/tasks/worktree/remote | 已有 Task/TaskOutput/KillTask/SendMessage/TeamCreate/TeamDelete/TeamOutput/TeamSendMessage/TeamDispatch/TeamSchedule/TeamAutoSchedule/TeamCoordinate/ResumeTask/Sleep/Brief/ScheduleCron/RemoteTrigger 入口、sidechain metadata/lifecycle、task progress event、显式与 settings 默认 owned worktree 创建/清理、sparse/symlink settings 应用、`run:true` subagent nested tool loop、agent permission mode/allowlist 过滤，以及 session-scoped team/schedule/remote trigger manifest、daemon heartbeat CLI/state/status/stop/tick/start/restart 控制面审计和跨 session state discovery、remote service manifest 与 `/status show remote` discovery、remote registrationUrl/authToken 注册状态文件、remote poll URL/cursor 与 websocket_url 多帧/tick 消息泵、WebSocket 基础重连/backoff/连接计数审计、callback stream primitive 和 daemon 常驻托管接线、ScheduleCron manual trigger/run_due/turn-start due tick、team coordinator_task_id 元数据、TeamOutput coordinator status、TeamSendMessage target routing、TeamDispatch individualized assignments、TeamSchedule deterministic member assignments、TeamAutoSchedule coordinator briefing + member assignments、coordinator briefing、structured handoff brief、remote trigger injection/event_id dedupe、bridge direct `/remote-trigger`/`/remote-service` HTTP endpoint、WebSocket `remote_trigger`/`remote_status`/`hello`/`health`/`manifest` action 和 remote_trigger/remote_service/websocket_protocol manifest capability；完整 CCR 云端 WebSocket 协议 hardening、多 agent 后台调度循环和模型驱动团队自动调度仍未完成 |
 | 全量测试 | 当前 `go test ./...` 通过 |
 
+M4 补充：tool executor 会围绕 `PreToolUse`、`PostToolUse` 和 `PermissionDenied` hook 发出 `hook_started`、`hook_completed`、`hook_failed`、`hook_blocked` 进度事件，携带 phase/tool/hook_index 以及阻断、错误、权限行为和 input 更新摘要；conversation runner 已通过现有 tool progress 通道透出这些事件。command-backed hook 执行、PermissionRequest hook 和 hook telemetry 仍未完成。
+
 M10 补充：plugin command/agent 的 allowed tool frontmatter 解析现在只在顶层逗号或空白处分隔，保留括号、方括号和引号内的逗号/空白，避免 `Bash(git commit -m "x,y")` 这类 tool pattern 被误拆。
 
 M10 补充：新增 `TaskOutput`/`AgentOutputTool` 和 `KillTask`/`TaskStop` 内置工具；`TaskOutput` 可列出当前 session 的 sidechain task，或按 task/sidechain ID 读取状态、summary、tail 输出和 agent metadata，`KillTask` 会通过 sidechain manager 写入 cancelled lifecycle summary。完整 AgentTool 执行循环、progress event streaming、resume command UI 和 worktree isolation 仍未完成。

docs/claude-code-go-rewrite-plan.md

@@ -141,6 +141,10 @@ test/parity/                 # golden tests against TS/official behavior
 - hook/classifier/permission prompt 接入点。
 - sandbox adapter 接口。
 
+当前进度：
+
+- 本轮补充：tool executor 会围绕 `PreToolUse`、`PostToolUse` 和 `PermissionDenied` hook 发出 `hook_started`、`hook_completed`、`hook_failed`、`hook_blocked` 进度事件，携带 phase/tool/hook_index 以及阻断、错误、权限行为和 input 更新摘要；conversation runner 已通过现有 tool progress 通道透出这些事件。command-backed hook 执行、PermissionRequest hook 和 hook telemetry 仍未宣称完成。
+
 验收：
 
 - allow/deny/ask、path rule、MCP rule、agent rule、mode rule 有覆盖。

docs/first-second-parity-audit.md

@@ -85,14 +85,14 @@ Anthropic API 和 conversation：
 - OAuth support now includes production OAuth config, scope parsing, Claude.ai scope detection, auth URL construction, PKCE verifier/challenge, state generation, and expiry checks.
 - Session/history support now includes CC-compatible prompt history references, pasted text/image placeholder parsing, paste-cache hashing and retrieval, `history.jsonl` append/load, current-session-first up-arrow ordering, ctrl+r-style deduped timestamped history, `CLAUDE_CODE_SKIP_PROMPT_HISTORY`, remote session event pagination helpers, lenient transcript loading, legacy progress parent-bridge recovery, compact-boundary pruning, snip removal/relink replay, metadata entry collection, leaf UUID calculation, conversation-chain reconstruction, orphaned parallel tool-result recovery, content-replacement record loading/reconstruction, tombstone metadata delete/relink replay, and tombstone-style transcript message removal with a size guard.
 - Anthropic API layer now covers streaming accumulation, usage update/accumulation semantics, non-streaming max token cap, thinking-budget adjustment, retry/backoff with `Retry-After` and `x-should-retry`, context-overflow `max_tokens` retry adjustment, beta-header dedupe, custom request headers, basic prompt cache breakpoint/cache-reference/cache-edits placement, prompt dump JSONL capture for init/new user messages/non-streaming responses/stream chunks, and CC-compatible USD cost calculation for known Claude models including cache read/write, web search requests, and Opus 4.6 fast-tier pricing.
-- Tool runtime now includes concurrency partitioning, ordered concurrent execution, interrupt behavior/defaults, max result size metadata, oversized result persistence, pre/post/permission-denied hook dispatch, hook-driven input updates/blocking, lifecycle progress events, and pre-call cancellation checks.
+- Tool runtime now includes concurrency partitioning, ordered concurrent execution, interrupt behavior/defaults, max result size metadata, oversized result persistence, pre/post/permission-denied hook dispatch, hook-driven input updates/blocking, executor hook phase progress events, lifecycle progress events, and pre-call cancellation checks.
 - Conversation runner can now use streaming clients, aggregate stream events into assistant messages, run tool calls through the orchestrator, preserve transcript append behavior, and apply CC-style per-message aggregate tool-result budget replacement before API requests with persisted replacement records for resume.
 
 ## Still Missing For 100% Compatibility
 
 The following items remain incomplete and must not be treated as done:
 
-- Full permission hook flow: `PreToolUse`, `PermissionRequest`, `PostToolUse`, blocking hook results, hook progress, hook telemetry.
+- Full permission hook flow gaps that remain: command-backed hook execution/runtime policy, `PermissionRequest` hook parity, richer hook telemetry, and full UI/SDK surfacing beyond the current executor hook phase progress events.
 - Auto mode / YOLO classifier: transcript construction, two-stage classifier, XML/tool-use parsing, prompt dump, denial circuit breaker, model gating, and fallback behavior.
 - Interactive permission prompt flow: REPL dialogs, bridge/channel/swarm permission relays, user feedback images, prompt race handling, cancellation.
 - Full filesystem permission parity gaps that remain: skill-scope allow suggestions, complete local/local-jsx slash-command execution wiring, command permission UI/SDK surfacing, forked/remote/MCP/plugin/bundled SkillTool behavior, skill prompt shell injection, complete auto-memory override policy, and deeper platform-specific Windows/WSL bypass handling.

internal/tool/executor.go

@@ -57,7 +57,7 @@ func (e Executor) Execute(ctx Context, use contracts.ToolUse, sink ProgressSink)
 	if err := t.Validate(ctx, raw); err != nil {
 		return ErrorResult(use, err), err
 	}
-	raw, err := e.runPreHooks(ctx, use, t, raw)
+	raw, err := e.runPreHooks(ctx, use, t, raw, sink)
 	if err != nil {
 		return ErrorResult(use, err), err
 	}
@@ -83,7 +83,7 @@ func (e Executor) Execute(ctx Context, use contracts.ToolUse, sink ProgressSink)
 				"permission": decision,
 			},
 		}
-		result = e.runPermissionDeniedHooks(ctx, use, t, raw, decision, result, permissionErr)
+		result = e.runPermissionDeniedHooks(ctx, use, t, raw, decision, result, permissionErr, sink)
 		_ = SendProgress(sink, use.ID, "permission_denied", map[string]any{"tool": t.Name(), "behavior": string(decision.Behavior)})
 		return result, permissionErr
 	}
@@ -97,7 +97,7 @@ func (e Executor) Execute(ctx Context, use contracts.ToolUse, sink ProgressSink)
 				"permission": decision,
 			},
 		}
-		result = e.runPermissionDeniedHooks(ctx, use, t, raw, decision, result, permissionErr)
+		result = e.runPermissionDeniedHooks(ctx, use, t, raw, decision, result, permissionErr, sink)
 		_ = SendProgress(sink, use.ID, "permission_denied", map[string]any{"tool": t.Name(), "behavior": string(decision.Behavior)})
 		return result, permissionErr
 	}
@@ -112,7 +112,7 @@ func (e Executor) Execute(ctx Context, use contracts.ToolUse, sink ProgressSink)
 	if err == nil {
 		result = e.limitResult(t, use, result)
 	}
-	result, hookErr := e.runPostHooks(ctx, use, t, raw, result, err)
+	result, hookErr := e.runPostHooks(ctx, use, t, raw, result, err, sink)
 	if hookErr != nil && err == nil {
 		err = hookErr
 	}
@@ -143,11 +143,13 @@ func (s defaultToolUseProgressSink) Send(progress contracts.ToolProgress) error
 	return s.sink.Send(progress)
 }
 
-func (e Executor) runPreHooks(ctx Context, use contracts.ToolUse, t Tool, raw json.RawMessage) (json.RawMessage, error) {
+func (e Executor) runPreHooks(ctx Context, use contracts.ToolUse, t Tool, raw json.RawMessage, sink ProgressSink) (json.RawMessage, error) {
 	current := normalizeRawInput(raw)
-	for _, hook := range e.Hooks {
+	for idx, hook := range e.Hooks {
+		_ = e.sendHookProgress(sink, use.ID, t, HookPreToolUse, idx, "hook_started", nil)
 		result, err := hook.RunToolHook(ctx, HookEvent{Phase: HookPreToolUse, ToolUse: use, ToolName: t.Name(), Input: current})
 		if err != nil {
+			_ = e.sendHookProgress(sink, use.ID, t, HookPreToolUse, idx, "hook_failed", map[string]any{"error": err.Error()})
 			return current, err
 		}
 		if len(result.UpdatedInput) > 0 {
@@ -157,20 +159,31 @@ func (e Executor) runPreHooks(ctx Context, use contracts.ToolUse, t Tool, raw js
 			if result.Message == "" {
 				result.Message = "blocked by PreToolUse hook"
 			}
+			_ = e.sendHookProgress(sink, use.ID, t, HookPreToolUse, idx, "hook_blocked", map[string]any{"message": result.Message})
 			return current, HookBlockedError{Phase: HookPreToolUse, Message: result.Message, Metadata: result.Metadata}
 		}
+		data := map[string]any{}
+		if len(result.UpdatedInput) > 0 {
+			data["updated_input"] = true
+		}
+		if result.Message != "" {
+			data["message"] = result.Message
+		}
+		_ = e.sendHookProgress(sink, use.ID, t, HookPreToolUse, idx, "hook_completed", data)
 	}
 	return current, nil
 }
 
-func (e Executor) runPermissionDeniedHooks(ctx Context, use contracts.ToolUse, t Tool, raw json.RawMessage, decision contracts.PermissionDecision, result contracts.ToolResult, originalErr error) contracts.ToolResult {
-	for _, hook := range e.Hooks {
+func (e Executor) runPermissionDeniedHooks(ctx Context, use contracts.ToolUse, t Tool, raw json.RawMessage, decision contracts.PermissionDecision, result contracts.ToolResult, originalErr error, sink ProgressSink) contracts.ToolResult {
+	for idx, hook := range e.Hooks {
+		_ = e.sendHookProgress(sink, use.ID, t, HookPermissionDenied, idx, "hook_started", map[string]any{"behavior": string(decision.Behavior)})
 		hookResult, err := hook.RunToolHook(ctx, HookEvent{Phase: HookPermissionDenied, ToolUse: use, ToolName: t.Name(), Input: raw, Decision: &decision, Result: &result, Error: originalErr.Error()})
 		if result.Meta == nil {
 			result.Meta = map[string]any{}
 		}
 		if err != nil {
 			result.Meta["permission_denied_hook_error"] = err.Error()
+			_ = e.sendHookProgress(sink, use.ID, t, HookPermissionDenied, idx, "hook_failed", map[string]any{"behavior": string(decision.Behavior), "error": err.Error()})
 			continue
 		}
 		if hookResult.Message != "" {
@@ -179,24 +192,32 @@ func (e Executor) runPermissionDeniedHooks(ctx Context, use contracts.ToolUse, t
 		if len(hookResult.Metadata) > 0 {
 			result.Meta["permission_denied_hook"] = hookResult.Metadata
 		}
+		data := map[string]any{"behavior": string(decision.Behavior)}
+		if hookResult.Message != "" {
+			data["message"] = hookResult.Message
+		}
+		_ = e.sendHookProgress(sink, use.ID, t, HookPermissionDenied, idx, "hook_completed", data)
 	}
 	return result
 }
 
-func (e Executor) runPostHooks(ctx Context, use contracts.ToolUse, t Tool, raw json.RawMessage, result contracts.ToolResult, callErr error) (contracts.ToolResult, error) {
+func (e Executor) runPostHooks(ctx Context, use contracts.ToolUse, t Tool, raw json.RawMessage, result contracts.ToolResult, callErr error, sink ProgressSink) (contracts.ToolResult, error) {
 	var errText string
 	if callErr != nil {
 		errText = callErr.Error()
 	}
-	for _, hook := range e.Hooks {
+	for idx, hook := range e.Hooks {
+		_ = e.sendHookProgress(sink, use.ID, t, HookPostToolUse, idx, "hook_started", nil)
 		hookResult, err := hook.RunToolHook(ctx, HookEvent{Phase: HookPostToolUse, ToolUse: use, ToolName: t.Name(), Input: raw, Result: &result, Error: errText})
 		if err != nil {
+			_ = e.sendHookProgress(sink, use.ID, t, HookPostToolUse, idx, "hook_failed", map[string]any{"error": err.Error()})
 			return result, err
 		}
 		if hookResult.Block {
 			if hookResult.Message == "" {
 				hookResult.Message = "blocked by PostToolUse hook"
 			}
+			_ = e.sendHookProgress(sink, use.ID, t, HookPostToolUse, idx, "hook_blocked", map[string]any{"message": hookResult.Message})
 			return result, HookBlockedError{Phase: HookPostToolUse, Message: hookResult.Message, Metadata: hookResult.Metadata}
 		}
 		if len(hookResult.Metadata) > 0 {
@@ -205,10 +226,25 @@ func (e Executor) runPostHooks(ctx Context, use contracts.ToolUse, t Tool, raw j
 			}
 			result.Meta["post_tool_use_hook"] = hookResult.Metadata
 		}
+		data := map[string]any{}
+		if hookResult.Message != "" {
+			data["message"] = hookResult.Message
+		}
+		_ = e.sendHookProgress(sink, use.ID, t, HookPostToolUse, idx, "hook_completed", data)
 	}
 	return result, nil
 }
 
+func (e Executor) sendHookProgress(sink ProgressSink, toolUseID contracts.ID, t Tool, phase string, index int, progressType string, data map[string]any) error {
+	if data == nil {
+		data = map[string]any{}
+	}
+	data["tool"] = t.Name()
+	data["phase"] = phase
+	data["hook_index"] = index
+	return SendProgress(sink, toolUseID, progressType, data)
+}
+
 type HookBlockedError struct {
 	Phase    string
 	Message  string

internal/tool/tool_test.go

@@ -391,17 +391,22 @@ func TestExecutorHooksCanUpdateInputAndEmitProgress(t *testing.T) {
 	if result.Meta["post_tool_use_hook"].(map[string]any)["ok"] != true {
 		t.Fatalf("meta = %#v", result.Meta)
 	}
-	if got := progressTypes(progress); strings.Join(got, ",") != "started,custom,completed" {
+	wantProgress := "hook_started,hook_completed,hook_started,hook_completed,started,custom,hook_started,hook_completed,hook_started,hook_completed,completed"
+	if got := progressTypes(progress); strings.Join(got, ",") != wantProgress {
 		t.Fatalf("progress = %#v", got)
 	}
 	for _, item := range progress {
 		if item.ToolUseID != "toolu_hook" {
 			t.Fatalf("progress tool use id = %#v", progress)
 		}
 	}
+	if progress[0].Data["phase"] != HookPreToolUse || progress[1].Data["updated_input"] != true || progress[6].Data["phase"] != HookPostToolUse {
+		t.Fatalf("hook progress data = %#v", progress)
+	}
 }
 
 func TestExecutorPreHookCanBlock(t *testing.T) {
+	var progress []contracts.ToolProgress
 	registry, err := NewRegistry(FuncTool{
 		DefinitionValue: contracts.ToolDefinition{Name: "Read", ReadOnly: true},
 		CallFunc: func(ctx Context, raw json.RawMessage, sink ProgressSink) (contracts.ToolResult, error) {
@@ -417,11 +422,20 @@ func TestExecutorPreHookCanBlock(t *testing.T) {
 		Hooks: []Hook{HookFunc(func(ctx Context, event HookEvent) (HookResult, error) {
 			return HookResult{Block: true, Message: "blocked"}, nil
 		})},
-	}).Execute(Context{Context: context.Background()}, contracts.ToolUse{ID: "toolu_block", Name: "Read"}, nil)
+	}).Execute(Context{Context: context.Background()}, contracts.ToolUse{ID: "toolu_block", Name: "Read"}, ProgressFunc(func(p contracts.ToolProgress) error {
+		progress = append(progress, p)
+		return nil
+	}))
 	var blocked HookBlockedError
 	if !errors.As(err, &blocked) || blocked.Phase != HookPreToolUse {
 		t.Fatalf("error = %#v", err)
 	}
+	if got := progressTypes(progress); strings.Join(got, ",") != "hook_started,hook_blocked" {
+		t.Fatalf("progress = %#v", got)
+	}
+	if progress[1].Data["phase"] != HookPreToolUse || progress[1].Data["message"] != "blocked" {
+		t.Fatalf("progress data = %#v", progress)
+	}
 }
 
 func TestExecutorReturnsPermissionError(t *testing.T) {
@@ -524,6 +538,7 @@ func TestEnginePermissionDeciderSurfacesSandboxOverride(t *testing.T) {
 func TestExecutorRunsPermissionDeniedHook(t *testing.T) {
 	engine := permissions.NewEngine(contracts.PermissionContext{Mode: contracts.PermissionDontAsk})
 	hookCalled := false
+	var progress []contracts.ToolProgress
 	registry, err := NewRegistry(FuncTool{
 		DefinitionValue: contracts.ToolDefinition{Name: "Bash", Destructive: true},
 		CallFunc: func(ctx Context, raw json.RawMessage, sink ProgressSink) (contracts.ToolResult, error) {
@@ -546,14 +561,23 @@ func TestExecutorRunsPermissionDeniedHook(t *testing.T) {
 	}).Execute(Context{
 		Context:     context.Background(),
 		Permissions: NewEnginePermissionDecider(engine),
-	}, contracts.ToolUse{ID: "toolu_denied", Name: "Bash"}, nil)
+	}, contracts.ToolUse{ID: "toolu_denied", Name: "Bash"}, ProgressFunc(func(p contracts.ToolProgress) error {
+		progress = append(progress, p)
+		return nil
+	}))
 	var permissionErr PermissionError
 	if !errors.As(err, &permissionErr) {
 		t.Fatalf("error = %v, want PermissionError", err)
 	}
 	if !hookCalled || result.Meta["permission_denied_hook_message"] != "logged" {
 		t.Fatalf("hookCalled=%v result=%#v", hookCalled, result)
 	}
+	if got := progressTypes(progress); strings.Join(got, ",") != "hook_started,hook_completed,started,hook_started,hook_completed,permission_denied" {
+		t.Fatalf("progress = %#v", got)
+	}
+	if progress[3].Data["phase"] != HookPermissionDenied || progress[4].Data["message"] != "logged" || progress[4].Data["behavior"] != string(contracts.PermissionDeny) {
+		t.Fatalf("progress data = %#v", progress)
+	}
 }
 
 func TestExecutorHonorsCancelledContextBeforeCall(t *testing.T) {