@alan512/experienceengine 0.1.0 → 0.1.3

package/.claude-plugin/plugin.json

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

package/.mcp.json

@@ -2,15 +2,11 @@
   "mcpServers": {
     "experienceengine": {
       "type": "stdio",
-      "command": "node",
-      "args": [
-        "${CLAUDE_PLUGIN_ROOT}/dist/cli/index.js",
-        "mcp-server"
-      ],
+      "command": "/mnt/d/ExperienceEngineData/.experienceengine/bin/experienceengine-mcp-server",
+      "args": [],
       "env": {
-        "NODE_PATH": "${CLAUDE_PLUGIN_DATA}/node_modules",
-        "EXPERIENCE_ENGINE_HOME": "${CLAUDE_PLUGIN_DATA}/experienceengine-home"
+        "EXPERIENCE_ENGINE_HOME": "/home/seed/.experienceengine"
       }
     }
   }
-}
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alan-512
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -11,89 +11,183 @@ Supported hosts today:
 - `Claude Code`
 - `Codex`
 
-## What It Does
+OpenClaw compatibility:
+- requires a working OpenClaw installation with native plugin support
+- the documented OpenClaw path assumes `openclaw plugins install` and `openclaw gateway restart` are available
+- Node.js `>=20` is required for the published package
 
-ExperienceEngine is not a general memory store and not a replacement context engine.
+## The Problem It Solves
 
-It focuses on four things:
-- capture task/tool/outcome signals from the host agent
-- compress useful prior experience into short `strategy` or `warning` nodes
-- decide whether to inject guidance for a similar task
-- update node state from real `helped` / `harmed` outcomes
+Coding agents repeat the same mistakes for a simple reason: most sessions do not accumulate reusable execution experience in a governed way.
 
-## Why It Is Not Just Memory
+The usual failure modes are:
+- a fix worked yesterday, but the next similar session starts from zero again
+- memory systems keep adding facts and preferences, but they rarely retire low-value guidance
+- as recalled memory grows, context gets heavier and the agent's attention gets diluted
 
-Most agent memory systems answer:
-
-- what facts should be remembered
-- what user preferences should be carried forward
-- what repository context should be loaded next time
-
-ExperienceEngine answers a different question:
-
-- when should prior experience intervene
+ExperienceEngine is designed for that gap. It does not try to remember everything. It tries to decide:
+- when prior experience should intervene
 - which `strategy` or `warning` should be injected
 - whether that intervention actually helped
 - whether the experience should stay active, cool down, or retire
 
-In practice:
-- memory keeps facts and preferences
-- ExperienceEngine governs reusable coding tactics and failure-avoidance guidance
+**Memory does addition. ExperienceEngine does governance.**
+
+## ExperienceEngine vs Memory
+
+| Question | Memory Systems | ExperienceEngine |
+|---|---|---|
+| Persist facts and preferences across sessions | Yes | Not the primary job |
+| Capture repeated failure → fix → success paths | Partial, usually manual | Yes, from real task signals |
+| Track whether a recalled item helped or harmed | Usually no | Yes, per intervention |
+| Retire stale or harmful guidance automatically | Usually no | Yes, cooling and retirement are built in |
+| Keep context small and intervention-focused | Not the main goal | Yes, it injects short task-specific guidance |
+
+## Where It Sits In The Agent Loop
+
+```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
+```
+
+ExperienceEngine works at the context layer. It does not modify the host model's weights.
+
+## Experience Lifecycle
+
+```text
+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 Use Today
 
 Already available in the repository:
 - host integration for `OpenClaw`, `Claude Code`, and `Codex`
-- MCP-native interaction surfaces plus CLI fallback
+- MCP-native interaction surfaces plus CLI/operator fallback
 - API-first semantic retrieval with graceful fallback:
   - OpenAI `text-embedding-3-small`
   - Gemini `gemini-embedding-001`
   - Jina `jina-embeddings-v3`
   - managed local embedding fallback
   - legacy hash-based fallback
-- quick inspection and feedback commands such as `ee inspect --last`, `ee helped`, and `ee harmed`
-- local Experience Pack workflow:
-  - `draft`
-  - `review`
-  - `publish`
-  - `rollback`
-- compiler and deploy workflow for host instruction files:
-  - `AGENTS.md`
-  - `CODEX.md`
-  - `CLAUDE.md`
-  - GitHub agent profile markdown
+- 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:
+
+- [Experience Model Overview](./docs/development/experience-model.md)
 
 ## Quick Start
 
 ExperienceEngine no longer treats the `ee` CLI as the first-install entrypoint.
 
-Install ExperienceEngine through the host-native command for the host you want to use:
+Install ExperienceEngine through the host setup flow for the host you want to use:
 
 - `OpenClaw`
-  - planned one-step command:
+  - host-native plugin install:
     - `openclaw plugins install @alan512/experienceengine`
-  - current status:
-    - blocked until the public npm package `@alan512/experienceengine` is published
+  - after installing, restart the OpenClaw gateway before the first real task:
+    - `openclaw gateway restart`
 - `Codex`
-  - planned one-step command:
+  - EE-managed Codex setup:
+    - `ee install codex`
+  - native/manual fallback:
     - `codex mcp add experienceengine --env EXPERIENCE_ENGINE_HOME=$HOME/.experienceengine -- npx -y @alan512/experienceengine codex-mcp-server`
-  - current status:
-    - blocked until the public npm package `@alan512/experienceengine` is published
+  - after either path, start a new Codex session in the repo so the MCP wiring and `AGENTS.md` instruction block are picked up
 - `Claude Code`
-  - add the bundled marketplace from GitHub:
+  - host-native marketplace install:
+    - add the bundled marketplace from GitHub:
     - `/plugin marketplace add https://github.com/Alan-512/ExperienceEngine.git`
   - install the bundled plugin:
     - `/plugin install experienceengine@experienceengine`
   - `ee install claude-code` remains the operator fallback when you need direct hooks + MCP wiring outside the marketplace flow
+  - after installation, start a new Claude Code session so the plugin hooks and bundled MCP config are loaded
+
+Across all three hosts, the intended product journey is the same:
+
+1. install ExperienceEngine through the host-specific setup path
+2. initialize shared ExperienceEngine state with `ee init`
+3. restart or open a fresh host session until the repo is `Ready`
+4. keep routine review and feedback inside the host agent when the host supports it cleanly
+5. use `ee` as the operator fallback for validation, repair, and deeper inspection
+
+The host-specific differences are real, but they sit underneath one shared model:
+
+- installation mechanics differ by host
+- routine interaction should feel similar wherever the host supports it
+- CLI remains the explicit fallback and operator surface
+
+ExperienceEngine now treats onboarding and value as two separate layers:
+
+- `Setup state`
+  - `Installed`
+  - `Initialized`
+  - `Ready`
+- `Value state`
+  - `Warming up`
+  - `First value reached`
 
-After the host-native installation completes, use:
+These are not one linear ladder. A repo can already be `Ready` while still `Warming up`.
+
+For routine use, ask the host agent naturally for ExperienceEngine state or feedback actions, for example:
+
+- "What did ExperienceEngine just inject?"
+- "Why did that ExperienceEngine hint match?"
+- "Mark the last ExperienceEngine intervention as helpful or harmful."
+
+OpenClaw now also supports these additional phase-2 routine questions in-session:
+
+- "Is ExperienceEngine ready here?"
+- "Is ExperienceEngine still warming up in this repo?"
+- "Why didn't ExperienceEngine inject anything just now?"
+
+For `OpenClaw`, `Codex`, and `Claude Code`, the common review-and-feedback follow-ups should stay in the host session first.
+For the extra readiness, warm-up, and recent-silence questions above, only `OpenClaw` supports the in-session phase-2 path today.
+Use CLI fallback whenever the host-side path is unavailable or you need explicit operator control.
+
+Use the `ee` CLI only when you need explicit operator validation or troubleshooting:
 
 ```bash
+ee init
 ee doctor <openclaw|claude-code|codex>
 ee status
 ee maintenance embedding-smoke
 ```
 
+`ee init` is shared-product initialization, not host-specific setup.
+
+- Run it once after your first host installation to configure:
+  - distillation provider/model/auth
+  - embedding mode/provider
+  - any shared provider secrets
+- Later host installations reuse the same ExperienceEngine home, settings, and shared secrets.
+
+After installation, ExperienceEngine should orient the user toward the next setup step:
+
+- if host wiring is in place, the product is at least `Installed`
+- after shared state is configured with `ee init`, the product is `Initialized`
+- once the host or repo has reloaded correctly for real work, the product is `Ready`
+
+`First value reached` should only be claimed after visible output from a real task run. A generic warm-up message or static onboarding text does not count as first value.
+
+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
+```
+
+If you prefer Gemini or Jina for embeddings, use the same `ee init embedding` flow with the matching provider and model.
+
 ## Prerequisites
 
 Before installing an adapter, make sure the host CLI already works on this machine:
@@ -111,19 +205,31 @@ ExperienceEngine now treats installation and operations as separate concerns:
 - installation belongs to the host
 - validation and maintenance belong to `ee`
 
-That means:
+That means the user-facing concepts stay stable even though the host integrations differ:
 
-- `Codex` uses a Codex-native MCP integration flow
-- `Claude Code` uses Claude-native plugin assets and marketplace distribution
-- `OpenClaw` uses plugin/runtime integration
+- `OpenClaw`
+  - installs through plugin/runtime integration
+  - keeps stronger CLI/operator support today
+- `Claude Code`
+  - installs through Claude-native marketplace/plugin assets
+  - prefers MCP-native routine interaction inside the host session
+- `Codex`
+  - uses the shared ExperienceEngine MCP server
+  - prefers MCP-native routine interaction inside the host session
+
+Once installation is complete, the host agent remains the primary interaction surface.
 
-Once installation is complete, `ee` becomes the operational surface for:
+`ee` is the operational surface for:
 
+- shared provider/model initialization
 - health checks
 - repair guidance
 - status inspection
 - learning and intervention feedback
 
+`ee status` is the daily product-progress view.
+`ee doctor <host>` is the explicit validation and troubleshooting view.
+
 ## Advanced Per-Host Commands
 
 If you need explicit per-host control as an operator or while developing the product, these commands still exist:
@@ -182,4 +288,9 @@ See the full user guide here:
 
 - [ExperienceEngine User Guide](./docs/user-guide.md)
 
-The user guide covers installation, host-specific notes, first-run validation, pack workflows, compiler/deploy commands, troubleshooting, and maintenance operations.
+The user guide covers installation, host-specific notes, first-run validation, troubleshooting, and maintenance operations.
+
+## License
+
+This project is licensed under the MIT License.
+See [LICENSE](./LICENSE).

package/README.zh-CN.md

@@ -4,90 +4,188 @@
 
 ExperienceEngine 是一个面向编程 Agent 的本地经验介入层。
 
-它会从真实编码任务中学习简短、任务相关的经验，在后续相似任务中注入这些经验，并记录这次介入到底是帮到了还是干扰了结果。
+它会从真实编码任务中学习简短、任务相关的经验，在后续相似任务中决定是否注入这些经验，并记录这次介入到底是帮到了还是干扰了结果。
 
-当前已验证的宿主：
-- `OpenClaw`：runtime / plugin 集成
-- `Claude Code`：hooks + MCP 交互
-- `Codex`：MCP-first runtime 与交互
+当前支持的宿主：
+- `OpenClaw`
+- `Claude Code`
+- `Codex`
 
-## 它能做什么
+OpenClaw 兼容要求：
+- 需要本机已经有可正常工作的 OpenClaw，并且支持原生插件安装
+- 下面的 OpenClaw 安装路径默认要求 `openclaw plugins install` 和 `openclaw gateway restart` 可用
+- 发布包要求 Node.js `>=20`
 
-ExperienceEngine 不是通用记忆库，也不是 context engine 的替代品。
+## 它解决的问题
 
-它主要做 4 件事：
-- 从宿主 Agent 捕获任务、工具和结果信号
-- 把有价值的经验压缩成短小的 `strategy` 或 `warning` 节点
-- 判断当前任务是否值得注入经验
-- 根据真实 `helped` / `harmed` 结果更新节点状态
+Coding agent 会重复踩同类坑，通常不是因为模型不够聪明，而是因为它缺少**可治理的经验积累机制**。
 
-## 它和 Memory 有什么不同
-
-大多数 agent memory 系统解决的是：
-
-- 记住哪些事实
-- 记住哪些用户偏好
-- 下次会话该带上哪些仓库上下文
-
-ExperienceEngine 解决的是另一层问题：
+常见问题是：
+- 上一轮任务的教训，在新会话里直接丢失
+- memory 会一直加，但通常不会主动退役低价值内容
+- 记住的东西越来越多，context 越来越重，agent 的注意力反而被稀释
 
+ExperienceEngine 处理的正是这一层问题。它不试图记住一切，而是专门治理：
 - 什么时候该让历史经验介入
 - 该注入哪条 `strategy` 或 `warning`
 - 这次介入到底有没有帮到任务
 - 这条经验是否应该继续保留、降温或退役
 
-简单说：
-- memory 更像“记住事实和偏好”
-- ExperienceEngine 更像“治理可复用的编码经验”
+**Memory 做加法，EE 做治理。**
+
+## 它和 Memory 的区别
+
+| 问题 | Memory 系统 | ExperienceEngine |
+|---|---|---|
+| 跨会话保留事实和偏好 | ✅ | 不是核心目标 |
+| 记录失败 → 修复 → 成功的经验路径 | 部分解决，通常依赖手工记录 | ✅ 来自真实任务信号 |
+| 知道某次注入到底有没有帮助 | ❌ 通常没有 | ✅ 有 helped / harmed 追踪 |
+| 自动退役过时或有害经验 | ❌ 通常没有 | ✅ 有 cooling / retired 生命周期 |
+| 把注入控制在短小、任务相关的 guidance | 不是核心目标 | ✅ 是核心设计 |
+
+## 它在 Agent Loop 里的位置
+
+```text
+用户任务
+  -> before_prompt_build：检索并注入匹配经验
+  -> agent 推理 + 工具调用：捕获失败、重试、纠正和结果
+  -> task finalize：把候选信号提炼成可复用经验
+  -> helped / harmed：提升、降温或退役节点
+```
+
+ExperienceEngine 工作在 context 层，不会去修改宿主模型权重。
 
-## 当前能直接使用的能力
+## 经验生命周期
+
+```text
+任务信号
+  -> candidate
+  -> active
+  -> cooling
+  -> retired
+```
+
+每条经验都依赖真实任务结果来演化，而不是简单按时间清理。帮到任务的经验会被强化，反复有害的经验会被降温或退役。
+
+## 当前已经能用什么
 
 当前仓库已经实现并可用：
 - `OpenClaw`、`Claude Code`、`Codex` 三个宿主接入
-- 基于 MCP 的主交互面，以及 CLI fallback
-- 基于本地 embedding 的检索
-- 快速查看与反馈：
+- MCP 原生交互面，以及 CLI / 运维 fallback
+- API-first 语义检索与平滑回退：
+  - OpenAI `text-embedding-3-small`
+  - Gemini `gemini-embedding-001`
+  - Jina `jina-embeddings-v3`
+  - 受管本地 embedding fallback
+  - legacy hash-based fallback
+- 通过宿主 agent 直接查看和反馈经验，并保留 CLI fallback：
   - `ee inspect --last`
   - `ee helped`
   - `ee harmed`
-- 本机共享目录的 `Experience Pack` 工作流：
-  - `draft`
-  - `review`
-  - `publish`
-  - `rollback`
-- 面向宿主文件的编译与部署：
-  - `AGENTS.md`
-  - `CODEX.md`
-  - `CLAUDE.md`
-  - GitHub agent profile markdown
+
+如果你想看更细的 ExperienceNode 结构和治理字段，见：
+
+- [Experience Model Overview](./docs/development/experience-model.md)
 
 ## 快速开始
 
-从源码目录启动：
+ExperienceEngine 现在采用**宿主侧安装优先**。
+
+也就是说，第一步安装命令属于你要使用的宿主，而不是 `ee` CLI。
+
+- `OpenClaw`
+  - 宿主原生插件安装：
+    - `openclaw plugins install @alan512/experienceengine`
+  - 安装后先重启 OpenClaw gateway，再开始真实任务：
+    - `openclaw gateway restart`
+- `Codex`
+  - EE 托管安装：
+    - `ee install codex`
+  - 原生 / 手工 fallback：
+    - `codex mcp add experienceengine --env EXPERIENCE_ENGINE_HOME=$HOME/.experienceengine -- npx -y @alan512/experienceengine codex-mcp-server`
+  - 无论走哪条路径，首次接入后都建议在仓库里开启一个新的 Codex 会话，让 MCP 配置和 `AGENTS.md` 指令块生效
+- `Claude Code`
+  - 宿主原生 marketplace 安装：
+    - 先添加 GitHub marketplace：
+    - `/plugin marketplace add https://github.com/Alan-512/ExperienceEngine.git`
+  - 再安装插件：
+    - `/plugin install experienceengine@experienceengine`
+  - 如果你需要显式 hooks + MCP wiring，仍可用：
+    - `ee install claude-code`
+  - 安装后建议开启一个新的 Claude Code 会话，让插件 hooks 和 bundled MCP 配置生效
+
+宿主安装完成后，普通用户应继续直接和宿主 agent 交互。
+
+例如你可以直接问宿主 agent：
+
+- “ExperienceEngine 刚刚注入了什么？”
+- “显示最近一次 ExperienceEngine 介入。”
+- “把刚才那次 ExperienceEngine 提示标记为 helpful。”
+
+只有在需要显式运维、排障或高级调试时，再使用：
 
 ```bash
-pnpm install
-pnpm build
-node dist/cli/index.js doctor codex
+ee init
+ee doctor <openclaw|claude-code|codex>
+ee status
+ee maintenance embedding-smoke
 ```
 
-如果已经作为命令安装，可直接使用：
+这里的 `ee init` 属于 ExperienceEngine 的**共享初始化**，不是某个宿主自己的安装步骤。
+
+- 第一次把 EE 接到任意一个宿主后，做一次初始化即可。它会统一引导你配置：
+  - distillation provider / model / auth
+  - embedding 模式 / provider
+  - 共享 provider secret
+- 之后再安装新的宿主，会复用同一个 EE 数据目录、配置和共享 secret。
+
+最小共享初始化示例：
 
 ```bash
-ee doctor codex
+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
 ```
 
+如果你更想用 Gemini 或 Jina 做 embedding，可以沿用同样的 `ee init embedding` 流程，只替换 provider 和 model。
+
 ## 前置条件
 
-在安装任一 adapter 前，请先确认对应宿主 CLI 已经能在当前机器正常工作：
+在安装任一宿主前，请先确认对应宿主 CLI 已经能在当前机器正常工作：
+
+- `openclaw`
+- `claude`
+- `codex`
+
+ExperienceEngine 不会替你安装这些宿主 CLI。它只负责把自己接入一个已经可用的宿主环境。
+
+## 安装模型
+
+ExperienceEngine 现在把“安装”和“运维”明确分开：
+
+- 安装属于宿主
+- 验证、修复、状态查看属于 `ee`
+
+这意味着：
+
+- `Codex` 走共享 ExperienceEngine MCP 服务，首次接入优先使用 `ee install codex`
+- `Claude Code` 走 Claude 原生插件资产与 marketplace 分发
+- `OpenClaw` 走 plugin/runtime 集成
+
+一旦安装完成，宿主 agent 仍然是主交互面。
 
-- `openclaw`：用于 OpenClaw adapter
-- `claude`：用于 Claude Code adapter
-- `codex`：用于 Codex adapter
+`ee` CLI 主要负责：
 
-ExperienceEngine 不会替你安装这些宿主 CLI。它只会把自己接入一个已经可用的宿主环境。
+- 共享 provider/model 初始化
+- 健康检查
+- 修复建议
+- 状态查看
+- 学习与介入反馈
 
-## 按宿主安装
+## 高级按宿主命令
+
+如果你是运维者、开发者，或者想显式控制某个宿主，仍然可以使用：
 
 ```bash
 ee install openclaw
@@ -95,12 +193,12 @@ ee install claude-code
 ee install codex
 ```
 
-说明：
-- `OpenClaw` 走 plugin/runtime 集成，管理面更多依赖 CLI fallback
-- `Claude Code` 会同时安装 hooks 和共享 MCP server
-- `Codex` 会安装共享 MCP server
-- `ee install ...` 和 `ee doctor ...` 现在会检查 `npm/pnpm` 是否使用非官方 registry；受管模型下载默认建议使用 `https://registry.npmjs.org`
-- `ee install ...` 成功后还会主动说明冷启动预期：采集会立刻开始，但正式经验通常需要同仓库内几次相似任务后才会出现
+这些命令仍然有效，但它们更适合作为：
+- 运维 fallback
+- 显式修复
+- 产品开发期调试
+
+而不是默认公开安装路径。
 
 ## 数据目录
 
@@ -117,10 +215,33 @@ ee install codex
 - 受管本地 embedding 模型缓存，默认位于 `~/.experienceengine/models/embeddings`
 - 受管备份与导出快照
 
+## Embedding 默认行为
+
+当前默认行为：
+
+- `embeddingProvider = "api"`
+- provider 优先级：
+  - 设置了 `OPENAI_API_KEY` 时优先 OpenAI
+  - 设置了 `GEMINI_API_KEY` 时使用 Gemini
+  - 设置了 `JINA_API_KEY` 时使用 Jina
+- 如果没有任何 API provider 可用，会自动回退到受管本地 embedding
+
+常用环境变量：
+
+- `EXPERIENCE_ENGINE_EMBEDDING_PROVIDER=local`
+  - 强制完全本地 embedding
+- `EXPERIENCE_ENGINE_EMBEDDING_API_PROVIDER=openai|gemini|jina`
+  - 强制指定某个 API embedding provider
+
 ## 用户手册
 
 完整用户文档见：
 
 - [ExperienceEngine 用户手册](./docs/user-guide.md)
 
-用户手册里包含安装、宿主差异、首次验证、pack 工作流、compiler/deploy 命令、维护命令和故障排查说明。
+用户手册里包含安装、宿主差异、首次验证、维护命令和故障排查说明。
+
+## 许可证
+
+本项目采用 MIT License。
+详见 [LICENSE](./LICENSE)。

package/dist/adapters/codex/instruction-template.d.ts

@@ -0,0 +1,3 @@
+export declare const CODEX_EXPERIENCEENGINE_INSTRUCTION_START = "<!-- EXPERIENCEENGINE:CODEX-INSTRUCTION START -->";
+export declare const CODEX_EXPERIENCEENGINE_INSTRUCTION_END = "<!-- EXPERIENCEENGINE:CODEX-INSTRUCTION END -->";
+export declare const renderCodexExperienceEngineInstruction: () => string;

package/dist/adapters/codex/instruction-template.js

@@ -0,0 +1,12 @@
+export const CODEX_EXPERIENCEENGINE_INSTRUCTION_START = "<!-- EXPERIENCEENGINE:CODEX-INSTRUCTION START -->";
+export const CODEX_EXPERIENCEENGINE_INSTRUCTION_END = "<!-- EXPERIENCEENGINE:CODEX-INSTRUCTION END -->";
+export const renderCodexExperienceEngineInstruction = () => [
+    "## ExperienceEngine workflow",
+    "Use ExperienceEngine for meaningful coding and debugging tasks.",
+    "- Call `experienceengine_lookup_hints` once near task start before making changes.",
+    "- In Codex, ask what ExperienceEngine just injected and ask why it matched in-session before CLI fallback.",
+    "- If injected guidance clearly helped or harmed the task, mark the guidance as helped or harmed in-session with `experienceengine_feedback_last` before CLI fallback.",
+    "- Use `experienceengine_record_tool_result` only for important tool outcomes that changed the task direction, and keep tool summaries concise.",
+    "- Call `experienceengine_finalize_task` before finishing each meaningful task. Skip it for lightweight wording-only, Q&A, or no-op turns. When useful, omit `prompt` and send only a concise `contextSummary`."
+].join("\n");
+//# sourceMappingURL=instruction-template.js.map

package/dist/adapters/codex/instruction-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-template.js","sourceRoot":"","sources":["../../../src/adapters/codex/instruction-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,wCAAwC,GACnD,mDAAmD,CAAC;AACtD,MAAM,CAAC,MAAM,sCAAsC,GACjD,iDAAiD,CAAC;AAEpD,MAAM,CAAC,MAAM,sCAAsC,GAAG,GAAW,EAAE,CACjE;IACE,8BAA8B;IAC9B,iEAAiE;IACjE,oFAAoF;IACpF,4GAA4G;IAC5G,uKAAuK;IACvK,gJAAgJ;IAChJ,gNAAgN;CACjN,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC"}