@@ -160,7 +160,7 @@ Supply the original checker's required tool/configuration options to `task verif
 | `plan CATEGORY LANGUAGE` | Preview selections and gaps | Not a certified execution plan |
 | `hook plan` | Route a versioned host event to a candidate check tier | Reads bounded JSON on stdin; exit 3, no check or host blocking |
 | `hook execute` | Run read-only discovery, bounded Stop guidance, task-bound recheck, selected Python Ruff feedback, or a live pre-commit index safety preview | Explicit timeout; repair reuses `task verify` and never closes a task or approves delivery |
-| `hook claude post-tool-use` | Convert a successful Claude Code file-tool event into bounded Rust edit feedback | Candidate soft Hook; no plugin runtime binding or delivery gate yet |
+| `hook claude <session-start\|post-tool-use\|post-tool-use-failure\|stop>` | Map Claude Code lifecycle events to read-only discovery, bounded edit feedback, no-check failure feedback, or local next-step guidance | Candidate soft Hooks; Stop offers one task continuation at most; no plugin runtime binding or delivery gate yet |
 | `lint python / java / typescript / go` | Run selected native checks | Adapter-specific options and scope |
 | `comments rust`, `build rust` | Documentation and type checking | Build does not run project tests |
 | `cve rust / python / typescript` | Native advisory observations | Database identity/freshness and full coverage remain limited |
 
@@ -159,7 +159,7 @@ codeguard task verify "$TASK_ID" . --format json
 | `tools list / verify`、`doctor` | 查看工具和有限环境探测 | 显式 Ruff doctor 探测；`tools install --apply` 受阻 |
 | `plan CATEGORY LANGUAGE` | 预览选择和缺口 | 不是已认证执行计划 |
 | `hook execute` | 启动只读发现、Stop 有界下一步、按任务原工具复检、Python 编辑局部反馈及显式 Git 工具的提交面安全预览 | 必须给超时；复检不自动关闭任务，推送/CI 仍未接线，不构成宿主交付门禁 |
-| `hook claude post-tool-use` | 将 Claude Code 成功文件工具事件转换为有界 Rust 编辑反馈 | 候选软 Hook；尚无插件二进制绑定或交付门禁 |
+| `hook claude <session-start\|post-tool-use\|post-tool-use-failure\|stop>` | 将 Claude Code 生命周期事件映射为只读发现、局部编辑反馈、失败不检查或本地下一步指引 | 候选软 Hook；Stop 最多引导一次继续；尚无插件二进制绑定或交付门禁 |
 | `lint python / java / typescript / go` | 执行已接入原生检查 | 参数和范围因适配器而异 |
 | `comments rust`、`build rust` | 文档与类型检查 | build 不运行项目测试 |
 | `cve rust / python / typescript` | 原生漏洞公告观察 | 漏洞库身份、时效及完整覆盖仍有限 |
 
@@ -1,4 +1,4 @@
-//! Claude Code 文件工具事件到 Rust 快检的受限转换；只回传脱敏对话摘要。
+//! Claude Code 生命周期事件到 Rust 路由的受限转换；只回传脱敏对话摘要。
 
 use crate::hook_execute_command::execute_host_input;
 use codeguard_core::{HookEvent, HookTriggerInput, HookWriteOutcome};
@@ -11,21 +11,28 @@ use std::process::ExitCode;
 const MAX_HOST_INPUT_BYTES: u64 = 1024 * 1024;
 const MAX_CONTEXT_CHARS: usize = 1200;
 
-/// 从 Claude Code stdin 读取成功的文件工具事件并注入局部检查摘要。
+/// 从 Claude Code stdin 读取生命周期事件并注入受限检查摘要。
 /// 参数包含项目根和原 `hook execute` 的显式选项；返回宿主退出码而非质量结论。
 pub fn run(args: &[String]) -> ExitCode {
     let [event, rest @ ..] = args else {
         eprintln!("需要 Claude Code 事件与项目路径");
         return ExitCode::from(2);
     };
-    if event != "post-tool-use" || rest.first().is_none_or(|value| value.starts_with('-')) {
-        eprintln!("目前仅支持 post-tool-use PATH --timeout DURATION --format=json");
+    let Some((host_event, route_event)) = mapped_event(event) else {
+        eprintln!("支持 session-start、post-tool-use、post-tool-use-failure、stop");
+        return ExitCode::from(2);
+    };
+    if rest.first().is_none_or(|value| value.starts_with('-')) {
+        eprintln!("需要 PATH --timeout DURATION --format=json");
         return ExitCode::from(2);
     }
     let root = match Path::new(&rest[0]).canonicalize() {
         Ok(root) if root.is_dir() => root,
         _ => {
-            print_context("范围未确定：项目根不可读取；本次源码检查未运行，交付未评估。");
+            print_context(
+                host_event,
+                "范围未确定：项目根不可读取；本次源码检查未运行，交付未评估。",
+            );
             return ExitCode::SUCCESS;
         }
     };
@@ -38,41 +45,135 @@ pub fn run(args: &[String]) -> ExitCode {
         || raw.is_empty()
         || raw.len() as u64 > MAX_HOST_INPUT_BYTES
     {
-        print_context("范围未确定：宿主事件缺失或超出输入预算；本次源码检查未运行，交付未评估。");
+        print_context(
+            host_event,
+            "范围未确定：宿主事件缺失或超出输入预算；本次源码检查未运行，交付未评估。",
+        );
         return ExitCode::SUCCESS;
     }
     let host = match codeguard_adapters::parse_unique_json(&raw) {
         Ok(host) => host,
         Err(_) => {
-            print_context("范围未确定：宿主事件格式无效；本次源码检查未运行，交付未评估。");
-            return ExitCode::SUCCESS;
-        }
-    };
-    let path = match selected_file(&root, &host) {
-        Some(path) => path,
-        None => {
             print_context(
-                "范围未确定：成功编辑事件没有可核对的项目内普通文件；本次源码检查未运行，交付未评估。",
+                host_event,
+                "范围未确定：宿主事件格式无效；本次源码检查未运行，交付未评估。",
             );
             return ExitCode::SUCCESS;
         }
     };
+    if host["hook_event_name"] != host_event || !valid_cwd(&root, &host) {
+        print_context(
+            host_event,
+            "范围未确定：宿主事件或工作目录不匹配；本次源码检查未运行，交付未评估。",
+        );
+        return ExitCode::SUCCESS;
+    }
+    if route_event == HookEvent::SessionStart
+        && !matches!(
+            host["source"].as_str(),
+            Some("startup" | "resume" | "clear" | "compact" | "fork")
+        )
+    {
+        print_context(
+            host_event,
+            "范围未确定：会话来源无效；只读发现未运行，交付未评估。",
+        );
+        return ExitCode::SUCCESS;
+    }
+    if route_event == HookEvent::FileChanged
+        && host_event == "PostToolUseFailure"
+        && (!matches!(
+            host["tool_name"].as_str(),
+            Some("Write" | "Edit" | "MultiEdit")
+        ) || !host["tool_input"].is_object()
+            || !host["error"].is_string())
+    {
+        print_context(
+            host_event,
+            "范围未确定：失败编辑事件无效；本次源码检查未运行，交付未评估。",
+        );
+        return ExitCode::SUCCESS;
+    }
+    let path = if host_event == "PostToolUse" {
+        match selected_file(&root, &host) {
+            Some(path) => Some(path),
+            None => {
+                print_context(
+                    host_event,
+                    "范围未确定：成功编辑事件没有可核对的项目内普通文件；本次源码检查未运行，交付未评估。",
+                );
+                return ExitCode::SUCCESS;
+            }
+        }
+    } else {
+        None
+    };
+    if route_event == HookEvent::Stop && !host["stop_hook_active"].is_boolean() {
+        print_context(
+            host_event,
+            "范围未确定：Stop 状态缺失；只读指引未运行，交付未评估。",
+        );
+        return ExitCode::SUCCESS;
+    }
     let input = HookTriggerInput {
-        event: HookEvent::FileChanged,
-        changed_paths: vec![path.clone()],
+        event: route_event,
+        changed_paths: path.iter().cloned().collect(),
         task_id: None,
-        write_outcome: HookWriteOutcome::Confirmed,
+        write_outcome: if host_event == "PostToolUseFailure" {
+            HookWriteOutcome::Failed
+        } else {
+            HookWriteOutcome::Confirmed
+        },
         host_claims_blocking: false,
     };
     match execute_host_input(rest, &input) {
-        Ok((report, _)) => print_context(&summarize(&path, &report)),
-        Err(_) => {
-            print_context("CodeGuard：宿主事件参数或路由无效；本次源码检查未运行，交付未评估。")
+        Ok((report, _)) => {
+            let context = match route_event {
+                HookEvent::SessionStart => summarize_discovery(&report),
+                HookEvent::Stop => summarize_stop(&report, host["stop_hook_active"] == true),
+                HookEvent::FileChanged if host_event == "PostToolUseFailure" => {
+                    "CodeGuard：写入失败，本次源码检查未运行；请先处理工具错误，交付未评估。"
+                        .to_owned()
+                }
+                HookEvent::FileChanged => {
+                    summarize(path.as_deref().unwrap_or("<changed-file>"), &report)
+                }
+                _ => "CodeGuard：宿主事件未运行，交付未评估。".to_owned(),
+            };
+            if route_event == HookEvent::Stop {
+                print_stop_context(
+                    &context,
+                    safe_task_id(&report).is_some() && host["stop_hook_active"] == false,
+                );
+            } else {
+                print_context(host_event, &context);
+            }
         }
+        Err(_) => print_context(
+            host_event,
+            "CodeGuard：宿主事件参数或路由无效；本次源码检查未运行，交付未评估。",
+        ),
     }
     ExitCode::SUCCESS
 }
 
+fn mapped_event(event: &str) -> Option<(&'static str, HookEvent)> {
+    match event {
+        "session-start" => Some(("SessionStart", HookEvent::SessionStart)),
+        "post-tool-use" => Some(("PostToolUse", HookEvent::FileChanged)),
+        "post-tool-use-failure" => Some(("PostToolUseFailure", HookEvent::FileChanged)),
+        "stop" => Some(("Stop", HookEvent::Stop)),
+        _ => None,
+    }
+}
+
+fn valid_cwd(root: &Path, host: &Value) -> bool {
+    host["cwd"].as_str().is_some_and(|cwd| {
+        let cwd = Path::new(cwd);
+        cwd.is_absolute() && cwd.canonicalize().is_ok_and(|cwd| cwd.starts_with(root))
+    })
+}
+
 fn selected_file(root: &Path, host: &Value) -> Option<String> {
     if host["hook_event_name"] != "PostToolUse"
         || !matches!(
@@ -82,10 +183,6 @@ fn selected_file(root: &Path, host: &Value) -> Option<String> {
     {
         return None;
     }
-    let cwd = Path::new(host["cwd"].as_str()?);
-    if !cwd.is_absolute() || !cwd.canonicalize().ok()?.starts_with(root) {
-        return None;
-    }
     let path = PathBuf::from(host["tool_input"]["file_path"].as_str()?);
     if !host["tool_response"].is_object() {
         return None;
@@ -106,6 +203,63 @@ fn selected_file(root: &Path, host: &Value) -> Option<String> {
     Some(relative.to_owned())
 }
 
+fn summarize_discovery(report: &Value) -> String {
+    if report["execution"] != "read_only_discovery" {
+        return "CodeGuard：会话启动只读发现未运行；源码检查未运行，交付未评估。".into();
+    }
+    let languages = report["local_feedback"]["languages"]
+        .as_array()
+        .into_iter()
+        .flat_map(|items| items.iter())
+        .filter_map(Value::as_str)
+        .filter(|language| {
+            language.len() <= 24
+                && language
+                    .bytes()
+                    .all(|byte| byte.is_ascii_lowercase() || byte == b'-')
+        })
+        .take(8)
+        .collect::<Vec<_>>();
+    let languages = if languages.is_empty() {
+        "未识别".to_owned()
+    } else {
+        languages.join(", ")
+    };
+    let count = report["local_feedback"]["checker_count"]
+        .as_u64()
+        .unwrap_or(0);
+    let complete = report["local_feedback"]["observation_complete"] == true;
+    let status = if complete { "完成" } else { "不完整" };
+    format!(
+        "CodeGuard：会话启动只读发现{status}；语言 {languages}，检查器配置观察 {count} 项。源码检查未运行，交付未评估。"
+    )
+}
+
+fn safe_task_id(report: &Value) -> Option<&str> {
+    report["local_feedback"]["task_id"].as_str().filter(|task| {
+        task.len() <= 64
+            && task.starts_with("CG-")
+            && task[3..]
+                .bytes()
+                .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-')
+    })
+}
+
+fn summarize_stop(report: &Value, already_continuing: bool) -> String {
+    if report["execution"] != "read_only_guidance" {
+        return "CodeGuard：结束时只读指引未运行；请显式执行 codeguard next . --format=json，交付未评估。".into();
+    }
+    match safe_task_id(report) {
+        Some(task) if !already_continuing => format!(
+            "CodeGuard：待处理任务 {task}；请读取 codeguard next . --format=json 并按原检查器复检。结束指引不运行源码检查，交付未评估。"
+        ),
+        Some(task) => format!(
+            "CodeGuard：待处理任务 {task}；本轮已在 Stop 后继续，避免重复唤醒。结束指引不运行源码检查，交付未评估。"
+        ),
+        None => "CodeGuard：没有可展示的待处理任务不代表检查通过；交付前仍需新鲜完整检查。结束指引不运行源码检查，交付未评估。".into(),
+    }
+}
+
 fn summarize(path: &str, report: &Value) -> String {
     let label = if path.len() <= 128
         && path
@@ -171,15 +325,35 @@ fn summarize(path: &str, report: &Value) -> String {
     summary.chars().take(MAX_CONTEXT_CHARS).collect()
 }
 
-fn print_context(context: &str) {
-    println!(
-        "{}",
-        json!({
-            "hookSpecificOutput": {
-                "hookEventName":"PostToolUse",
-                "additionalContext":context
-            },
-            "systemMessage":"CodeGuard 局部检查反馈"
-        })
-    );
+fn print_context(event: &str, context: &str) {
+    if event == "Stop" {
+        println!("{}", json!({"systemMessage":context}));
+    } else {
+        let label = match event {
+            "SessionStart" => "CodeGuard 项目发现反馈",
+            "PostToolUseFailure" => "CodeGuard 写入失败反馈",
+            _ => "CodeGuard 局部检查反馈",
+        };
+        println!(
+            "{}",
+            json!({
+                "hookSpecificOutput": {"hookEventName":event,"additionalContext":context},
+                "systemMessage":label
+            })
+        );
+    }
+}
+
+fn print_stop_context(context: &str, continue_once: bool) {
+    if continue_once {
+        println!(
+            "{}",
+            json!({
+                "hookSpecificOutput":{"hookEventName":"Stop","additionalContext":context},
+                "systemMessage":"CodeGuard 待处理任务指引"
+            })
+        );
+    } else {
+        println!("{}", json!({"systemMessage":context}));
+    }
 }
@@ -33,7 +33,7 @@ fn main() -> ExitCode {
                 "局部事件执行：hook execute PATH --timeout DURATION --format=json [--ruff-tool ABS_PATH] [--git-tool ABS_PATH] 从 stdin 读取同一事件协议；启动只发现、Stop 有界只读提示、repair_ready 复用 task verify 原工具复检、确认 Python 编辑调用 Ruff 局部快检、显式 Git 工具的 pre_commit 观察真实 index；完整交付始终 not_evaluated。"
             );
             println!(
-                "Claude 候选软 Hook：hook claude post-tool-use PATH --timeout DURATION --format=json [--ruff-tool ABS_PATH] 从 stdin 读取成功文件工具事件，规范化项目内路径后复用 Rust 局部执行器；输出有界 additionalContext，宿主退出 0 不表示检查或交付通过。插件尚未自动接线。"
+                "Claude 候选软 Hook：hook claude <session-start|post-tool-use|post-tool-use-failure|stop> PATH --timeout DURATION --format=json [--ruff-tool ABS_PATH] 从 stdin 读取宿主事件；启动只读发现，成功保存局部 Ruff，失败保存不检查，Stop 有界读取下一步；输出脱敏反馈，宿主退出 0 不表示检查或交付通过。插件尚未自动接线。"
             );
             println!(
                 "check all 的 Python CVE 节点可用 --pip-audit-tool ABS_PATH --pip-audit-version VERSION；逐构建根反馈原生结果或锁文件/工具阻塞，不签发零漏洞结论。"