@alan512/experienceengine 0.2.0 → 0.3.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "experienceengine",
   "description": "Context-aware experience intervention controller for Claude Code.",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": {
     "name": "ExperienceEngine"
   },

package/.mcp.json

@@ -2,11 +2,10 @@
   "mcpServers": {
     "experienceengine": {
       "type": "stdio",
-      "command": "/mnt/d/ExperienceEngineData/.experienceengine/bin/experienceengine-mcp-server",
-      "args": [],
-      "env": {
-        "EXPERIENCE_ENGINE_HOME": "/home/seed/.experienceengine"
-      }
+      "command": "bash",
+      "args": [
+        "${CLAUDE_PLUGIN_ROOT}/scripts/claude-plugin/mcp-server.sh"
+      ]
     }
   }
-}
+}

package/README.md

@@ -12,40 +12,30 @@ Supported hosts today: `OpenClaw`, `Claude Code`, `Codex`
 
 Without ExperienceEngine:
 - the agent repeats the same SQLite migration mistake in a similar repo
+- it opens the DB before running the migration, then wastes turns retrying the wrong path
 
 With ExperienceEngine:
-- it injects a hint like: `Run the migration before opening the DB connection`
-- later you mark that intervention `helpful` or `harmful`
-- the experience can then become active, cool down, or retire
+- at task start, it injects one short constraint like: `Run the migration before opening the DB connection`
+- the host agent avoids the same failed path instead of rediscovering it from scratch
+- after the task, ExperienceEngine usually updates that guidance automatically from the real outcome
+- if the guidance later starts harming similar tasks, ExperienceEngine can cool, quarantine, or retire it
 
-```text
-task signals -> distilled experience -> retrieval -> short intervention -> feedback -> governance
-```
+Task flow: `task signals -> distilled experience -> retrieval -> short intervention -> feedback -> governance`
 
 <details>
 <summary>Example host transcript</summary>
 
-```text
 User: Fix the SQLite startup failure in this repo.
 
-ExperienceEngine:
-  Hint: Run the migration before opening the DB connection.
+Host agent: ExperienceEngine found a prior successful fix pattern in this repo: `Run the migration before opening the DB connection.` I’ll apply the migration first, then retry startup.
 
-Host agent:
-  I’ll apply the migration first, then retry startup.
+User: Why did that ExperienceEngine hint match?
 
-User:
-  Why did that ExperienceEngine hint match?
+Host agent: It matched a prior task in this repo with the same SQLite startup pattern and a successful migration-first fix.
 
-Host agent:
-  It matched a prior task in this repo with the same SQLite startup pattern and a successful migration-first fix.
+User: So ExperienceEngine is trying to keep me off the same bad path?
 
-User:
-  Mark the last ExperienceEngine intervention as helpful.
-
-Host agent:
-  Recorded. That experience gets stronger for similar future tasks.
-```
+Host agent: Yes. It reused a repo-local success pattern before the next tool call, and it will usually score the outcome automatically after this run.
 
 </details>
 
@@ -55,6 +45,12 @@ Host agent:
 
 Fastest host-specific install paths:
 
+If you plan to use `ee init`, `ee install ...`, or other operator commands, install the CLI first:
+
+```bash
+npm install -g @alan512/experienceengine
+```
+
 - `OpenClaw`
   - `openclaw plugins install @alan512/experienceengine`
   - `openclaw gateway restart`
@@ -91,7 +87,7 @@ Do not use ExperienceEngine if:
 |---|---|---|---|
 | `OpenClaw` | native plugin install | host-native | most complete today |
 | `Claude Code` | marketplace plugin, with `ee install claude-code` fallback | MCP + plugin hooks | supported |
-| `Codex` | `ee install codex`, with native MCP fallback | MCP-native | supported |
+| `Codex` | `ee install codex`, with native MCP fallback | hooks + MCP | supported |
 
 ## Why It Exists
 
@@ -110,44 +106,50 @@ ExperienceEngine is designed for intervention governance, not general memory acc
 | Keep context small and intervention-focused | Not the main goal | Yes, it injects short task-specific guidance |
 | Generic document lookup | Common fit | Not the primary job |
 
+## Why It Is Not Just Another Memory Layer
+
+ExperienceEngine is not trying to remember more things than the host. Its core job is to govern whether learned guidance should keep affecting future tasks.
+
+- most learning work happens after the task, so the current task does not need to wait for the full experience pipeline
+- each learned node moves through a lifecycle such as `candidate`, `active`, `cooling`, and `retired`
+- delivery is governed separately from storage, so harmful guidance can be cooled, quarantined, or removed from normal live injection
+- posttask review can revise whether a hint actually helped, harmed, or stayed uncertain
+- delivery decisions are persisted even when no hint is shipped, so skipped turns can still be explained later
+- high-match same-repo experience can move out of conservative delivery after successful reuse, while cross-repo reuse stays cautious unless there is stronger evidence
+- the product goal is production-safe reuse, not maximum recall
+
 ## Where It Sits In The Agent Loop
 
 At a high level, ExperienceEngine operates around the agent loop like this:
 
-```text
-User task
-  -> before_prompt_build: retrieve and inject matching experience
-  -> agent reasoning + tools: capture failures, retries, corrections, and outcomes
-  -> task finalization: distill new candidates into reusable experience
-  -> helped / harmed feedback: promote, cool, or retire nodes
-```
+- `User task`
+- `before_prompt_build`: retrieve and inject matching experience
+- `agent reasoning + tools`: capture failures, retries, corrections, and outcomes
+- `task finalization`: distill new candidates into reusable experience
+- `helped / harmed feedback`: promote, cool, or retire nodes
 
 ExperienceEngine works at the context layer. It does not modify the host model's weights.
 
 ## Experience Lifecycle
 
-```text
-task signals
-  -> candidate
-  -> active
-  -> cooling
-  -> retired
-```
+`task signals -> candidate -> active -> cooling -> retired`
 
 Each node moves through that lifecycle using real task outcomes, not just time-based cleanup. Helpful experience gets reinforced; harmful experience gets cooled or retired.
 
 ## What You Can Do Today
 
 - reuse short guidance from similar coding work
-- review why a hint matched
-- mark interventions helpful or harmful
-- inspect active, cooling, and retired experience
+- review why a hint matched or why nothing injected
+- let ExperienceEngine automatically reinforce, cool, quarantine, or retire guidance from real task outcomes
+- override the last intervention as helpful or harmful when the automatic judgment needs correction
+- inspect active, cooling, quarantined, and retired experience
 - run across `OpenClaw`, `Claude Code`, and `Codex`
 
 ### Under The Hood
 
 - MCP-native interaction surfaces plus CLI/operator fallback
 - semantic retrieval with API and local fallback
+- deterministic match scorecards that separate same-repo confidence from broader cross-repo reuse
 - host-agent driven inspection and feedback, with CLI fallback commands such as `ee inspect --last`, `ee helped`, and `ee harmed`
 
 For a more detailed explanation of what ExperienceEngine records and how an experience node is structured, see:
@@ -157,17 +159,18 @@ For a more detailed explanation of what ExperienceEngine records and how an expe
 ## Current Status
 
 - Stable: core experience lifecycle, inspect/helped/harmed loop, host integrations, CLI/operator fallback
-- Good path today: `OpenClaw` native plugin install
+- Recommended first path: use the host you already work in; `OpenClaw` currently has the deepest host-native integration
 - Evolving: retrieval tuning, provider strategy, advanced host UX
-- If you want the smoothest first experience today, start with `OpenClaw`.
+- If you are starting from scratch and do not already have a preferred host, `OpenClaw` is the most complete native-plugin path.
 
 ## What First Success Looks Like
 
 After installation and initialization, the first visible signs of value are:
 
-- ExperienceEngine injects a short hint during a real task
-- the host can explain why that hint matched
-- feedback on the last intervention affects future reuse
+- a repeated task avoids a previously known bad path instead of rediscovering it
+- ExperienceEngine injects only a short repo-relevant constraint instead of bloating the prompt
+- the host can explain why that hint matched or why nothing was injected
+- the task outcome usually updates future delivery automatically
 - `ee inspect --last` shows the recent intervention and related node state
 
 ## Prerequisites
@@ -183,7 +186,8 @@ Before installing an adapter, make sure the host CLI already works on this machi
 OpenClaw notes:
 - requires a working OpenClaw installation with native plugin support
 - the documented OpenClaw path assumes `openclaw plugins install` and `openclaw gateway restart` are available
-- OpenClaw now uses the shared background learning loop by default
+- ExperienceEngine resolves the real project root from OpenClaw hook payloads or nearby repo markers; if OpenClaw only reports its global workspace, ExperienceEngine isolates that session instead of reusing unrelated global-workspace experience
+- OpenClaw uses the shared background learning loop by default
 - OpenClaw still keeps async hybrid posttask review disabled by default; `ee status` and `ee doctor openclaw` show that explicitly
 
 General package requirement:
@@ -207,7 +211,8 @@ Install ExperienceEngine through the host setup flow for the host you want to us
     - `ee install codex`
   - native/manual fallback:
     - see the advanced example below if you need direct MCP wiring
-  - after either path, start a new Codex session in the repo so the MCP wiring and `AGENTS.md` instruction block are picked up
+  - after either path, start a new Codex session in the repo so project hooks, MCP wiring, and the `AGENTS.md` instruction block are picked up
+  - in mixed Windows Codex App + WSL Codex CLI setups, the project `.codex/hooks.json` can be shared by both runtimes, while MCP registration remains runtime/user-level in each Codex home
 - `Claude Code`
   - host-native marketplace install:
     - add the bundled marketplace from GitHub:
@@ -243,23 +248,26 @@ After installation, ExperienceEngine should orient the user toward the next setu
 
 Minimal shared initialization example:
 
-```bash
-ee init distillation --provider openai --model gpt-4.1-mini --auth-mode api_key
-ee init secret OPENAI_API_KEY <your-api-key>
-ee init embedding --mode api --api-provider openai --model text-embedding-3-small
-ee init show
-```
+1. `ee init distillation --provider openai --model gpt-4.1-mini --auth-mode api_key`
+2. `ee init secret OPENAI_API_KEY <your-api-key>`
+3. `ee init embedding --mode api --api-provider openai --model text-embedding-3-small`
+4. `ee init show`
 
 If you prefer Gemini or Jina for embeddings, use the same `ee init embedding` flow with the matching provider and model.
 
 ### Routine Use vs Operator Use
 
-For routine use, ask the host agent naturally for ExperienceEngine state or feedback actions, for example:
+For routine use, ask the host agent naturally for ExperienceEngine state first. Automatic outcome attribution is the default path; manual feedback is mainly there when you want to correct that judgment.
+
+Examples:
 
 - "What did ExperienceEngine just inject?"
 - "Why did that ExperienceEngine hint match?"
+- "Why didn't ExperienceEngine inject anything just now?"
 - "Mark the last ExperienceEngine intervention as helpful or harmful."
 
+In normal use, you should not need to manually score every intervention. ExperienceEngine is designed to learn from real task outcomes automatically, while still letting you override the result when the automatic judgment is wrong.
+
 OpenClaw also supports these additional readiness and recent-silence questions in-session:
 
 - "Is ExperienceEngine ready here?"
@@ -303,6 +311,8 @@ ExperienceEngine separates:
 
 The host remains the primary interaction surface.
 `ee` remains the explicit operator surface for setup, validation, repair, status, and maintenance.
+For Codex, `ee status` and `ee doctor codex` also report whether the `ee` CLI fallback is available on `PATH`. Codex MCP wiring can still work when the CLI fallback is missing, but commands such as `ee inspect --last` need either a PATH-visible `ee` binary or an explicit package invocation.
+For mixed Windows Codex App + WSL Codex CLI use, treat `.codex/hooks.json` as repo-owned hook wiring and `~/.codex/config.toml` as per-runtime MCP wiring. `ee repair codex` refreshes the project hook launcher and removes stale project-scoped ExperienceEngine MCP config so Windows App and WSL CLI do not fight over one config file.
 
 ## Advanced Per-Host Commands (Operator / Development Only)
 
@@ -328,7 +338,8 @@ codex mcp add experienceengine --env EXPERIENCE_ENGINE_HOME=$HOME/.experienceeng
 Notes:
 - `OpenClaw` uses plugin/runtime integration (not `src/adapters/`) and CLI fallback for management.
 - `Claude Code` installs both hooks and the shared ExperienceEngine MCP server.
-- `Codex` installs the shared ExperienceEngine MCP server.
+- `Codex` installs Codex-native hooks plus the shared ExperienceEngine MCP server. `ee codex exec` remains the deterministic non-interactive fallback.
+- Codex `UserPromptSubmit` stays synchronous because it owns prompt-time experience injection. `PostToolUse` and `Stop` are queued for background processing by default. `PreToolUse` is not registered by default; set `EXPERIENCE_ENGINE_CODEX_PRETOOL_HOOK_ENABLED=1` only for synchronous gating experiments.
 - `ee install ...` and `ee doctor ...` now warn if `npm` or `pnpm` uses a non-official registry, because managed model downloads are most reliable with `https://registry.npmjs.org`.
 - successful `ee install ...` also explains the cold-start expectation: capture starts immediately, but formal experience usually appears after a few similar tasks in the same repo.
 

package/README.zh-CN.md

@@ -12,40 +12,30 @@ ExperienceEngine 是一个面向编程 Agent 的治理层。它复用真实执
 
 没有 ExperienceEngine：
 - agent 会在相似仓库里重复犯同样的 SQLite migration 错误
+- 它会先打开数据库、再补 migration，然后在错误方向上浪费几轮
 
 有 ExperienceEngine：
-- 它会注入一条提示，例如：`先执行 migration，再打开数据库连接`
-- 后续你可以把这次介入标记为 `helpful` 或 `harmful`
-- 这条经验会据此进入 active、降温或退役
+- 它会在真正调用工具之前注入一条很短的约束，例如：`先执行 migration，再打开数据库连接`
+- 宿主 agent 会直接避开上次已经踩过的错路，而不是重新试错
+- 任务结束后，ExperienceEngine 通常会根据真实结果自动更新这条 guidance
+- 如果这条 guidance 后面开始伤害相似任务，ExperienceEngine 会把它降温、隔离或退役
 
-```text
-任务信号 -> 提炼经验 -> 检索 -> 短提示注入 -> 反馈 -> 治理
-```
+任务流：`任务信号 -> 提炼经验 -> 检索 -> 短提示注入 -> 反馈 -> 治理`
 
 <details>
 <summary>宿主里的示例对话</summary>
 
-```text
 用户：修一下这个仓库里的 SQLite 启动失败问题。
 
-ExperienceEngine：
-  Hint: 先执行 migration，再打开数据库连接。
+宿主 agent：ExperienceEngine 在这个仓库里找到了一个之前成功过的修复模式：`先执行 migration，再打开数据库连接。` 我会先补 migration，然后再重试启动。
 
-宿主 agent：
-  我会先补 migration，然后再重试启动。
+用户：为什么这条 ExperienceEngine 提示会命中？
 
-用户：
-  为什么这条 ExperienceEngine 提示会命中？
+宿主 agent：它匹配到了这个仓库里过去一次相同的 SQLite 启动失败，以及当时成功的 migration-first 修复路径。
 
-宿主 agent：
-  它匹配到了这个仓库里过去一次相同的 SQLite 启动失败，以及当时成功的 migration-first 修复路径。
+用户：所以 ExperienceEngine 的作用，是提前把我从同样的错路上拉回来？
 
-用户：
-  把刚才那次 ExperienceEngine 介入标记为 helpful。
-
-宿主 agent：
-  已记录。之后遇到类似任务时，这条经验会更容易再次命中。
-```
+宿主 agent：对。它在下一次工具调用前复用了这个仓库里的成功路径，而且这次任务结束后通常会自动判断这条经验到底帮到了还是干扰了结果。
 
 </details>
 
@@ -55,6 +45,12 @@ ExperienceEngine：
 
 最快的宿主安装路径：
 
+如果你需要使用 `ee init`、`ee install ...` 或其他 operator 命令，请先安装 CLI：
+
+```bash
+npm install -g @alan512/experienceengine
+```
+
 - `OpenClaw`
   - `openclaw plugins install @alan512/experienceengine`
   - `openclaw gateway restart`
@@ -91,7 +87,7 @@ ExperienceEngine：
 |---|---|---|---|
 | `OpenClaw` | 原生插件安装 | 宿主原生 | 当前最完整 |
 | `Claude Code` | marketplace 插件，保留 `ee install claude-code` fallback | MCP + plugin hooks | 已支持 |
-| `Codex` | `ee install codex`，保留原生 MCP fallback | MCP 原生 | 已支持 |
+| `Codex` | `ee install codex`，保留原生 MCP fallback | hooks + MCP | 已支持 |
 
 ## 为什么要做这个
 
@@ -110,44 +106,50 @@ ExperienceEngine 的目标不是通用 memory 累积，而是**介入治理**。
 | 保持提示短小、任务相关 | 不是核心目标 | 是 |
 | 通用文档检索 | 常见适用场景 | 不是核心目标 |
 
+## 为什么它不是另一层记忆
+
+ExperienceEngine 不是想比宿主“记住更多东西”。它的核心价值，是持续治理一条已经学到的 guidance 还应不应该继续影响后续任务。
+
+- 大部分学习动作发生在任务之后，所以当前任务不需要等待整条经验处理链路跑完
+- 每条经验节点都会经历 `candidate`、`active`、`cooling`、`retired` 这样的生命周期
+- “存下来” 和 “还能不能继续上线” 是分开的，所以有害 guidance 可以被降温、隔离，或者退出正常注入路径
+- 任务结束后的审查会继续判断这条 hint 到底是帮到了、伤害了，还是仍然不确定
+- 即使这次没有注入 hint，delivery decision 也会被记录下来，所以之后仍然能解释为什么跳过
+- 同仓库高匹配经验在成功复用后可以从保守投放提升到正常投放；跨仓库复用默认仍保持保守，除非后续证据更强
+- 这个产品追求的是“生产安全的经验复用”，不是“尽量多记、尽量多召回”
+
 ## 它在 Agent Loop 里的位置
 
 从高层看，ExperienceEngine 围绕 agent loop 的位置是这样的：
 
-```text
-用户任务
-  -> before_prompt_build：检索并注入匹配经验
-  -> agent 推理 + 工具调用：捕获失败、重试、修正和结果
-  -> task finalize：把候选信号提炼成可复用经验
-  -> helped / harmed：提升、降温或退役节点
-```
+- `用户任务`
+- `before_prompt_build`：检索并注入匹配经验
+- `agent 推理 + 工具调用`：捕获失败、重试、修正和结果
+- `task finalize`：把候选信号提炼成可复用经验
+- `helped / harmed`：提升、降温或退役节点
 
 ExperienceEngine 工作在 context 层，不会修改宿主模型权重。
 
 ## 经验生命周期
 
-```text
-任务信号
-  -> candidate
-  -> active
-  -> cooling
-  -> retired
-```
+`任务信号 -> candidate -> active -> cooling -> retired`
 
 每条经验都根据真实任务结果演化，而不是按时间粗暴清理。帮到任务的经验会被强化，反复有害的经验会被降温或退役。
 
 ## 现在能做什么
 
 - 在相似编码任务里复用短 guidance
-- 查看某条 hint 为什么命中
-- 把最近一次介入标记为 helpful 或 harmful
-- 查看 active、cooling、retired 等生命周期状态
+- 查看某条 hint 为什么命中，或者为什么这次没有注入
+- 让 ExperienceEngine 根据真实任务结果自动强化、降温、隔离或退役 guidance
+- 当自动判断不准时，手动把最近一次介入标记为 helpful 或 harmful
+- 查看 active、cooling、quarantined、retired 等生命周期状态
 - 在 `OpenClaw`、`Claude Code`、`Codex` 三个宿主中使用
 
 ### 底层实现
 
 - MCP 原生交互面，加上 CLI / operator fallback
 - 支持 API 与本地回退的语义检索
+- 确定性的 match scorecard，用来区分同仓库高置信匹配和更宽泛的跨仓库复用
 - 宿主 agent 内可直接查看和反馈经验，CLI fallback 包括 `ee inspect --last`、`ee helped`、`ee harmed`
 
 如果你想看 ExperienceNode 结构和治理字段，见：
@@ -157,17 +159,18 @@ ExperienceEngine 工作在 context 层，不会修改宿主模型权重。
 ## 当前状态
 
 - Stable：核心经验生命周期、inspect/helped/harmed loop、宿主集成、CLI/operator fallback
-- 当前最顺滑的路径：`OpenClaw` 原生插件安装
+- 推荐优先路径：使用你已经在用的宿主；如果从零开始，`OpenClaw` 目前是最完整的原生插件路径
 - 仍在演进：retrieval 调优、provider 策略、更高级的宿主 UX
-- 如果你想最快拿到第一份顺滑体验，建议先从 `OpenClaw` 开始
+- 如果你还没有固定宿主，建议先从 `OpenClaw` 开始。
 
 ## 什么叫第一次真正成功
 
 安装并初始化后，第一次真正体现价值的信号通常是：
 
-- ExperienceEngine 在真实任务里注入了一条短 hint
-- 宿主能解释为什么这条 hint 会命中
-- 你对最近一次介入的反馈，会影响后续复用
+- 一类重复任务不再重走之前已经犯过的错路
+- ExperienceEngine 只注入一条很短、和当前仓库直接相关的约束，而不是把上下文塞满
+- 宿主能解释为什么这条 hint 会命中，或者为什么这次没有注入
+- 任务结果通常会自动影响以后是否继续投放这条经验
 - `ee inspect --last` 能看到最近的介入和相关节点状态
 
 ## 前置条件
@@ -183,6 +186,7 @@ ExperienceEngine 工作在 context 层，不会修改宿主模型权重。
 OpenClaw 说明：
 - 需要本机已有可正常工作的 OpenClaw，且支持原生插件安装
 - 下面的 OpenClaw 路径默认要求 `openclaw plugins install` 和 `openclaw gateway restart` 可用
+- ExperienceEngine 会从 OpenClaw hook payload 或附近仓库标记解析真实项目根目录；如果 OpenClaw 只上报全局 workspace，ExperienceEngine 会把该会话隔离起来，避免复用不相干的全局 workspace 经验
 
 通用包要求：
 - 发布包要求 Node.js `>=20`
@@ -205,7 +209,8 @@ ExperienceEngine 现在不再把 `ee` CLI 当成适用于所有宿主的统一
     - `ee install codex`
   - 原生 / 手工 fallback：
     - 如果你需要直接 MCP wiring，可参考后面的高级示例
-  - 无论走哪条路径，首次接入后都建议在仓库里开启一个新的 Codex 会话，让 MCP 配置和 `AGENTS.md` 指令块生效
+  - 无论走哪条路径，首次接入后都建议在仓库里开启一个新的 Codex 会话，让项目 hooks、MCP 配置和 `AGENTS.md` 指令块生效
+  - 如果同一个仓库同时用于 Windows Codex App 和 WSL Codex CLI，项目 `.codex/hooks.json` 可以共享；MCP 注册仍然属于每个运行时自己的 Codex home
 - `Claude Code`
   - 宿主原生 marketplace 安装：
     - 先添加 GitHub marketplace：
@@ -242,23 +247,26 @@ ExperienceEngine 现在不再把 `ee` CLI 当成适用于所有宿主的统一
 
 最小共享初始化示例：
 
-```bash
-ee init distillation --provider openai --model gpt-4.1-mini --auth-mode api_key
-ee init secret OPENAI_API_KEY <your-api-key>
-ee init embedding --mode api --api-provider openai --model text-embedding-3-small
-ee init show
-```
+1. `ee init distillation --provider openai --model gpt-4.1-mini --auth-mode api_key`
+2. `ee init secret OPENAI_API_KEY <your-api-key>`
+3. `ee init embedding --mode api --api-provider openai --model text-embedding-3-small`
+4. `ee init show`
 
 如果你更想用 Gemini 或 Jina 做 embedding，可以沿用同样的 `ee init embedding` 流程，只替换 provider 和 model。
 
 ### 日常使用与 Operator 使用
 
-日常使用时，优先直接问宿主 agent，例如：
+日常使用时，优先直接问宿主 agent 当前的 ExperienceEngine 状态。默认主路径是自动结果归因；手动 feedback 主要用于你觉得自动判断不准时的纠偏。
+
+例如：
 
 - “ExperienceEngine 刚刚注入了什么？”
 - “为什么那条 ExperienceEngine 提示会命中？”
+- “为什么这次 ExperienceEngine 没有注入？”
 - “把刚才那次 ExperienceEngine 介入标记为 helpful 或 harmful。”
 
+正常使用里，你不应该需要手动给每次介入都打分。ExperienceEngine 的默认路径是根据真实任务结果自动学习；只有当自动判断明显不对时，你再手动纠偏。
+
 OpenClaw 还支持这些 readiness / silence 问题：
 
 - “ExperienceEngine 这里 ready 了吗？”
@@ -302,6 +310,8 @@ ExperienceEngine 明确拆分：
 
 宿主仍然是主交互面。
 `ee` 仍然是显式的 operator 面，用于 setup、验证、修复、状态查看和维护。
+对于 Codex，`ee status` 和 `ee doctor codex` 还会显示 `ee` CLI fallback 是否在 `PATH` 上可用。Codex 的 MCP 接入在 CLI fallback 缺失时仍可能正常工作，但 `ee inspect --last` 这类命令需要 PATH 里有 `ee`，或者使用显式的包调用方式。
+如果同一个仓库同时用于 Windows Codex App 和 WSL Codex CLI，请把 `.codex/hooks.json` 当成仓库级 hook wiring，把 `~/.codex/config.toml` 当成每个运行时自己的 MCP wiring。`ee repair codex` 会刷新项目 hook launcher，并移除过期的项目级 ExperienceEngine MCP 配置，避免 Windows App 和 WSL CLI 争用同一个配置文件。
 
 ## 高级按宿主命令（仅限 Operator / 开发者）
 
@@ -327,7 +337,8 @@ codex mcp add experienceengine --env EXPERIENCE_ENGINE_HOME=$HOME/.experienceeng
 说明：
 - `OpenClaw` 走 plugin/runtime integration，而不是 `src/adapters/`
 - `Claude Code` 会安装 hooks 和共享 ExperienceEngine MCP 服务
-- `Codex` 会安装共享 ExperienceEngine MCP 服务
+- `Codex` 会安装 Codex 原生 hooks 和共享 ExperienceEngine MCP 服务。`ee codex exec` 仍是确定性的非交互 fallback。
+- Codex 的 `UserPromptSubmit` 保持同步，因为它负责 prompt-time experience injection。`PostToolUse` 和 `Stop` 默认排队后在后台处理。`PreToolUse` 默认不注册；只有同步 gating 实验需要时才设置 `EXPERIENCE_ENGINE_CODEX_PRETOOL_HOOK_ENABLED=1` 启用。
 - `ee install ...` 与 `ee doctor ...` 会在 `npm` / `pnpm` 使用非官方 registry 时给出提示，因为受管模型下载在 `https://registry.npmjs.org` 下最稳定
 - 成功执行 `ee install ...` 后，也会提醒冷启动预期：capture 会立刻开始，但 formal experience 一般需要在同一仓库里出现几次相似任务后才会形成
 

package/dist/adapters/codex/action-registry.d.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
-import type { ExperienceNodeType, ExperienceState } from "../../types/domain.js";
+import type { DeliveryState, ExperienceNodeType, ExperienceState, TaskType } from "../../types/domain.js";
+import type { HygieneFindingType, HygieneSeverity } from "../../maintenance/experience-hygiene.js";
+import type { ExportDraftRisk } from "../../maintenance/experience-export-drafts.js";
 export type CodexActionCategory = "inspect" | "state" | "admin" | "maintenance";
 export type CodexActionRiskLevel = "low" | "medium" | "high";
 export type CodexActionDefinition = {
@@ -29,6 +31,26 @@ type RegistryDeps = {
             nodeType: ExperienceNodeType;
         }) => Promise<unknown>;
         inspectLearningSummary: () => Promise<unknown>;
+        inspectReview: (args?: {
+            cwd?: string;
+            limit?: number;
+        }) => Promise<unknown>;
+        inspectHygiene: (args?: {
+            cwd?: string;
+            type?: HygieneFindingType;
+            severity?: HygieneSeverity;
+            limit?: number;
+        }) => Promise<unknown>;
+        inspectExportDrafts: (args?: {
+            cwd?: string;
+            nodeId?: string;
+            nodeType?: ExperienceNodeType;
+            taskFamily?: TaskType;
+            state?: ExperienceState;
+            deliveryState?: DeliveryState;
+            risk?: ExportDraftRisk;
+            limit?: number;
+        }) => Promise<unknown>;
         coolNode: (args: {
             nodeId: string;
         }) => Promise<unknown>;

package/dist/adapters/codex/action-registry.js

@@ -208,6 +208,79 @@ export const createCodexActionRegistry = (deps) => {
             examplePayload: {},
             handler: async () => deps.interactionSurface.inspectLearningSummary()
         },
+        {
+            id: "inspect_operator_review",
+            title: "Inspect Operator Review",
+            summary: "Inspect the read-only operator review workflow across repo policy, hygiene, and export drafts, with drill-down references only.",
+            category: "inspect",
+            riskLevel: "low",
+            requiresConfirmation: false,
+            inputSchema: z.object({
+                cwd: z.string().min(1).optional(),
+                limit: z.number().int().positive().optional()
+            }),
+            examplePayload: { cwd: "/path/to/repo", limit: 5 },
+            handler: async ({ cwd, limit }) => deps.interactionSurface.inspectReview({
+                cwd: typeof cwd === "string" ? cwd : undefined,
+                limit: typeof limit === "number" ? limit : undefined
+            })
+        },
+        {
+            id: "inspect_experience_hygiene",
+            title: "Inspect Experience Hygiene",
+            summary: "Inspect read-only EE hygiene findings for stale, duplicate, conflicting, over-generalized, or drifted guidance.",
+            category: "inspect",
+            riskLevel: "low",
+            requiresConfirmation: false,
+            inputSchema: z.object({
+                type: z.enum([
+                    "stale_experience",
+                    "duplicate_guidance",
+                    "conflicting_guidance",
+                    "over_generalized_guidance",
+                    "evidence_drift"
+                ]).optional(),
+                severity: z.enum(["high", "medium", "low"]).optional(),
+                cwd: z.string().min(1).optional(),
+                limit: z.number().int().positive().optional()
+            }),
+            examplePayload: { cwd: "/path/to/repo", severity: "high", limit: 10 },
+            handler: async ({ cwd, type, severity, limit }) => deps.interactionSurface.inspectHygiene({
+                cwd: typeof cwd === "string" ? cwd : undefined,
+                type: type,
+                severity: severity,
+                limit: typeof limit === "number" ? limit : undefined
+            })
+        },
+        {
+            id: "inspect_export_drafts",
+            title: "Inspect Export Drafts",
+            summary: "Inspect read-only review packages for guidance that may be exported outside local EE state.",
+            category: "inspect",
+            riskLevel: "low",
+            requiresConfirmation: false,
+            inputSchema: z.object({
+                cwd: z.string().min(1).optional(),
+                nodeId: z.string().min(1).optional(),
+                nodeType: z.enum(["strategy", "warning"]).optional(),
+                taskFamily: z.string().min(1).optional(),
+                state: z.enum(["candidate", "priority_candidate", "active", "cooling", "retired"]).optional(),
+                deliveryState: z.enum(["shadow_only", "conservative_only", "eligible", "quarantined"]).optional(),
+                risk: z.enum(["low", "medium", "high"]).optional(),
+                limit: z.number().int().positive().optional()
+            }),
+            examplePayload: { cwd: "/path/to/repo", state: "cooling", risk: "high", limit: 10 },
+            handler: async ({ cwd, nodeId, nodeType, taskFamily, state, deliveryState, risk, limit }) => deps.interactionSurface.inspectExportDrafts({
+                cwd: typeof cwd === "string" ? cwd : undefined,
+                nodeId: typeof nodeId === "string" ? nodeId : undefined,
+                nodeType: nodeType,
+                taskFamily: taskFamily,
+                state: state,
+                deliveryState: deliveryState,
+                risk: risk,
+                limit: typeof limit === "number" ? limit : undefined
+            })
+        },
         {
             id: "inspect_backup_inventory",
             title: "Inspect Backup Inventory",