v1.6 System Prompt 工程化 + 渐进式技能发现

重构 system prompt 为动态组装系统：PromptComposer 聚合核心身份、AGENTS.md 项目规范和 Skills 目录；新增 read_skill 工具实现技能按需加载；包重命名 internal/context -> internal/prompt 消除 stdlib 冲突。
v1.5 多工具并发执行
2026-05-17 00:05:31 +08:00 · 2026-05-16 23:20:03 +08:00 · 2026-05-15 18:32:57 +08:00 · 2026-05-15 17:11:43 +08:00 · 2026-05-15 11:24:42 +08:00 · 2026-05-14 20:35:44 +08:00
21 changed files with 1664 additions and 121 deletions
@@ -0,0 +1,8 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml
+# 基于编辑器的 HTTP 客户端请求
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
@@ -0,0 +1,9 @@
+# 欢迎来到 go-tiny-claw 项目工作区
+
+## 架构说明
+- 本项目采用 Go 语言编写，追求极致性能。
+- 所有的 API 接口都必须返回 JSON 格式，且包含 `code` 和 `message` 字段。
+- 所有的错误处理，必须返回中文报错信息，绝对禁止使用英文抛错。
+
+## 禁忌事项
+- 不允许删除根目录的任何文件。
@@ -0,0 +1,202 @@
+# go-tiny-claw
+
+一个轻量级的 AI Agent 引擎，基于 Go 语言实现标准的 **ReAct（Reasoning + Acting）** 循环模式。
+
+## 项目背景
+
+go-tiny-claw 受 Claude / OpenAI 的 Agent 概念启发，旨在提供一个简洁、可扩展的微型 Agent 框架核心。它定义了 Agent 与大模型交互的标准契约，让开发者可以快速搭建自己的 AI 助手应用。
+
+## 核心架构
+
+```
+┌─────────────────────────────────────────────┐
+│                AgentEngine                   │
+│  ┌──────────┐    ┌──────────┐               │
+│  │LLMProvider│    │ Registry │               │
+│  └─────┬────┘    └─────┬────┘               │
+│        │               │                    │
+│        ▼               ▼                    │
+│  大模型推理服务     本地工具执行              │
+└─────────────────────────────────────────────┘
+```
+
+### 模块说明
+
+| 包 | 说明 |
+|---|---|
+| `internal/engine` | **AgentEngine** — 核心驱动，实现 ReAct 主循环 |
+| `internal/provider` | **LLMProvider** 接口 — 与大模型通信的统一契约 |
+| `internal/schema` | 核心数据结构定义（Message、ToolCall、ToolResult） |
+| `internal/tools` | **Registry** 接口 — 工具的注册与分发执行 |
+
+### ReAct 循环流程
+
+1. 系统初始化 Context，注入用户指令
+2. 向大模型发起推理请求（含可用工具列表）
+3. 模型返回文本回复和/或工具调用请求
+4. 如果模型未请求工具调用 → 任务完成，退出循环
+5. 执行模型请求的工具，获取 Observation
+6. 将 Observation 追加到上下文，回到步骤 2
+
+## 快速开始
+
+```go
+package main
+
+import (
+    "context"
+    "go-tiny-claw/internal/engine"
+    "go-tiny-claw/internal/schema"
+)
+
+func main() {
+    provider := &mockProvider{}
+    registry := &mockRegistry{}
+    eng := engine.NewAgentEngine(provider, registry, "/path/to/workdir")
+    eng.Run(context.Background(), "你的指令")
+}
+```
+
+## 扩展
+
+- **替换 Provider**: 实现 `LLMProvider` 接口即可接入任意大模型（OpenAI、Claude、本地模型等）
+- **注册工具**: 实现 `Registry` 接口即可挂载自定义工具集（bash、文件操作、代码搜索等）
+- **自定义 Schema**: 基于 `schema` 包的数据结构可灵活扩展消息格式和工具定义
+
+## 版本历史
+
+### v1.5 — Edit 工具 + 四级容错替换 + 多工具并发执行
+
+#### 变更
+
+- **新增 EditFileTool** — 实现四级容错降级替换算法（L1 精确 → L2 换行符归一 → L3 Trim Space → L4 逐行去缩进滑动窗口），解决大模型代码修改时缩进丢失、换行符不一致等幻觉问题
+- **工具集扩展** — 工具集从 3 个（read / write / bash）扩展到 4 个（+ edit）
+- **多工具并发执行** — 引擎从串行改为并行：预分配结果切片 + `sync.WaitGroup` + 按索引无锁写入，模型一次请求多个工具时同时执行
+
+#### 踩坑记录
+
+| 问题 | 原因 | 解决 |
+|---|---|---|
+| 大模型生成的代码缩进不一致 | 模型推理时对源文件缩进感知不准，产生多一个空格或少一个 tab | 编辑工具内建多级模糊匹配 |
+| 同一段代码在文件中出现多次 | 模型给的 old_text 上下文不够 | 算法检测多匹配后返回错误给模型自愈 |
+| Windows 换行符 `\r\n` vs `\n` 不一致 | 模型通常输出 `\n`，Windows 文件可能是 `\r\n` | L2 换行符归一化：统一转 `\n` |
+| Goroutine 闭包捕获 loop 变量 | Go 的 loop 变量复用同一地址 | 将 `i`/`toolCall` 作为参数传入 goroutine |
+
+#### 经验教训
+
+1. **Agent 工具要做"容错输入，严格输出"** — 接受模型可能不完美的输入（多级模糊匹配），但输出清晰的错误信息帮模型自我纠正
+2. **工具语义要匹配模型的能力边界** — `edit_file`（给 old_text + new_text）比重写整个文件更适合 Agent，不要求模型完整认知整个文件
+3. **并发安全可以零成本** — 预分配切片 + 按索引写入 + 主 goroutine 串行读取，比加锁方案更简洁高效
+
+### v1.6 — System Prompt 工程化 + 渐进式技能发现
+
+#### 变更
+
+- **PromptComposer** — 新增 `internal/prompt` 包取代硬编码 system prompt，运行时动态组装：核心身份 → `AGENTS.md` 项目规范 → Skill 目录
+- **AGENTS.md** — 项目根目录的 Markdown 文件自动被识别并注入 system prompt，让非代码层面的架构规范可被 Agent 感知
+- **渐进式技能发现** — `SkillLoader` 扫描 `skills/<name>/SKILL.md`，system prompt 只注入技能目录（名称 + 一行描述），模型按需调用 `read_skill` 加载完整指令
+- **ReadSkillTool** — 工具集扩展到 5 个，接收技能名称返回完整 Skill.md 正文
+- **包重命名** — `internal/context` → `internal/prompt`，消除与标准库 `context` 包的命名冲突
+
+#### 踩坑记录
+
+| 问题 | 原因 | 解决 |
+|---|---|---|
+| 包名与标准库冲突 | `internal/context` 与 `context` 包同名，导入时被迫黑别名 `ctxpkg` | 重命名为 `prompt`，导入无歧义 |
+| prompt 全量注入浪费上下文 | List() 只返回摘要，Build() 仍需知道技能的完整存在 | 摘要注入 system prompt，正文通过 read_skill 按需加载，典型场景节省 70%+ context |
+
+#### 经验教训
+
+1. **上下文管理是 Agent 的核心杠杆** — system prompt 从 30 行硬编码字符串演变为动态组装系统，每项内容（身份 / 项目规范 / 技能）的增删都不需要改引擎代码
+2. **"先摘要后按需"适用于 Agent 的所有知识注入** — 无论是技能、文档还是 API 参考，把完整内容塞进 context 是最简单的做法，但渐进式加载才是可扩展的方案
+
+### v1.4 — 工具集扩展与 Windows 编码攻坚
+
+#### 变更
+
+- **新增 BashTool** — 执行本地 bash 命令，支持 30s 超时、错误原样回传（模型自愈）、8KB 输出截断
+- **新增 WriteFileTool** — 写文件到工作区，覆盖/新建均支持
+- **Windows GBK 编码修复** — 命令输出从 GBK 自动转 UTF-8（`golang.org/x/text/encoding/simplifiedchinese`），不依赖 `chcp`
+- **API 交互日志** — `OpenAIProvider.Generate` 新增请求/响应日志（阶段标记、消息数、工具数、ToolCall 明细）
+- **调试输出优化** — `dumpMessages` 移除 80 字符截断，完整展示上下文内容
+- **三段式任务演示** — `cmd/claw` 任务改为：查 Go 版本 → 写 helloworld.go → 编译运行
+
+#### 踩坑记录
+
+| 问题 | 原因 | 解决 |
+|---|---|---|
+| bash 输出中文乱码 | Windows 命令输出为 GBK 编码，Go 按 UTF-8 解析 | 引入 `golang.org/x/text`，检测编码后自动转换 |
+| `chcp 65001` 导致终端刷屏 | `chcp` 在子进程中修改代码页可能影响终端渲染 | 放弃 `chcp` 方案，改用 Go 原生编码转换 |
+| `utf8.Valid` 检查后仍乱码 | GBK 字节序列碰巧也合法于 UTF-8，跳过转换 | 去掉 `utf8.Valid` 判断，Windows 下一律转换 |
+| `helloworld.go` 导致编译失败 | 模型生成的测试文件含 `main` 函数，与项目 main.go 冲突 | 运行后清理 `helloworld.*` 测试产物 |
+
+#### 经验教训
+
+1. **编码问题不要依赖外部命令** — `chcp` 属于"改环境让输出配合你"，不可靠。Go 原生转码属于"你主动适应输出"，稳定可控
+2. **`utf8.Valid` 不能当编码检测器** — 它的语义是"是否合法 UTF-8"，不是"是否是 GBK"。GBK 和 UTF-8 有交集，用合法性判断编码方向是伪命题
+3. **Agent 的工具越多，越需要关注副作用** — 模型会写文件、执行命令，产生的文件（helloworld.go）可能反过来破坏项目结构。工具内部要做好隔离
+
+### v1.3 — Registry 实现重构与第一把真实工具
+
+#### 变更
+
+- **Registry 完整实现** — 从纯接口升级为 `registryImpl`，基于 `map[string]BaseTool` 实现 O(1) 路由查找、动态注册、错误自愈
+- **BaseTool 接口** — 定义工具的通用契约（`Name()` / `Definition()` / `Execute()`），所有具体工具统一实现
+- **首个真实工具 ReadFileTool** — 支持读取工作区文件，含路径穿越防护和 8000 字节截断
+- **调试可视化** — `AgentEngine` 和 `registryImpl` 实现 `String()` 方法，替代 16 进制内存地址
+- **ToolCall 执行日志** — 每轮工具执行后输出一行状态日志（`📋 ToolCall xxx: ✅ / ❌, 结果: ...`）
+- **cmd/claw 真实化** — 从 mockRegistry 切换到 `tools.NewRegistry()` + `ReadFileTool`
+
+#### 踩坑记录
+
+| 问题 | 原因 | 解决 |
+|---|---|---|
+| `fmt.Println(registry)` 输出 16 进制地址 | Go 默认打印指针/接口类型为内存地址，不展示内容 | 实现 `fmt.Stringer` 接口，自定义 `String()` 方法 |
+| Registry 接口加 `Register` 后旧代码编译失败 | `main.go` 的 mockRegistry 没有实现新增的 `Register` 方法 | 为 mockRegistry 补充空实现 `Register(tool tools.BaseTool) {}` |
+| 修改代码时需要同时兼容旧 mock 和新实现 | demo 代码和正式代码共用同一套接口 | 保留 mock 的兼容性（无操作 Register），新演示代码使用真实实现 |
+
+#### 经验教训
+
+1. **接口先于实现，但实现要跟上** — v1.0 就定义了 `Registry` 接口，但一直没有真实实现，导致 cmd 只能靠 mock 跑。抽象要尽早落地
+2. **工具系统用 map 路由天然适合 Agent** — 大模型输出工具名 → 直接 map key 查找 → O(1) 路由，简单高效，也方便运行时动态挂载工具
+3. **`String()` 是 Go 调试的性价比之王** — 三行代码换来看日志时不用猜内存地址，投入产出比极高
+
+### v1.2 — 真实模型接入与 Thinking 死循环修复
+
+#### 变更
+
+- **接入真实大模型** — 新增 `OpenAIProvider` 和 `ClaudeProvider`，分别基于 OpenAI V3 SDK 和 Anthropic SDK 连接 Deepseek API，替换原有的 Mock Provider
+- **Deepseek thinking 模式适配** — 修正 `reasoning_content` 字段丢失导致的 API 400 错误，在 `schema.Message` 中新增字段并在请求中回传
+- **Thinking 死循环修复** — 过渡指令只在首轮插入，防止模型每轮重复调用工具
+- **最大轮数保护** — 新增 `maxTurns = 10` 上限，防止意外死循环
+- **调试输出** — 新增 `dumpMessages` 和 `dumpTools`，每轮打印上下文消息和工具列表
+
+#### 踩坑记录
+
+| 问题 | 原因 | 解决 |
+|---|---|---|
+| API 400: `reasoning_content must be passed back` | Deepseek thinking 模式返回了 `reasoning_content` 字段，回传请求时未携带 | 从响应 RawJSON 中提取该字段，用 `param.Override` 注入原始 JSON 回传 |
+| 模型在 Phase 2 不调用工具 | Phase 1 的思考内容作为 Assistant 消息追加后，模型认为对话已结束 | 在思考后插入一条 User 角色过渡指令："根据推理，使用工具完成任务" |
+| 引擎死循环跑到 maxTurns | 过渡指令每轮都插入，模型每轮都被要求调用工具 | 过渡指令只在 `turnCount == 1` 时插入，后续轮次模型根据观察结果自行判断 |
+
+#### 经验教训
+
+1. **上下文即状态** — Agent 的所有行为都由上下文驱动。插入一条消息就能改变模型行为，不需要改代码逻辑
+2. **非标准 API 字段需手动处理** — 大模型厂商的扩展字段（如 `reasoning_content`）不在 SDK 类型中，需要从 RawJSON 手动提取并用注入方式回传
+3. **过渡指令的作用域很重要** — "使用工具"这种指令适合在首轮引导，重复出现会导致模型无法自行判断任务是否完成
+
+### v1.1 — 慢思考模式 (Thinking Phase)
+
+将 ReAct 循环从单阶段升级为双阶段架构：
+
+- **Phase 1 (Thinking)** — 剥夺工具访问权，强制模型先进行纯文本推理规划
+- **Phase 2 (Action)** — 恢复工具挂载，模型顺着推理结果执行精准的工具调用
+- 新增 `EnableThinking` 开关，兼容旧模式
+
+### v1.0 — ReAct 循环基础
+
+实现标准的单阶段 ReAct 循环：思考 → 调工具 → 观察 → 继续，直到任务完成。
+
+## License
+
+MIT
@@ -6,67 +6,49 @@ import (
 	"os"

 	"go-tiny-claw/internal/engine"
-	"go-tiny-claw/internal/schema"
+	"go-tiny-claw/internal/provider"
+	"go-tiny-claw/internal/tools"
 )

-// ==========================================
-// 1. 伪造的大模型 Provider
-// ==========================================
-type mockProvider struct {
-	turn int
-}
-
-// 模拟大模型的响应：第一轮请求执行 bash，第二轮输出最终结果
-func (m *mockProvider) Generate(ctx context.Context, msgs []schema.Message, _ []schema.ToolDefinition) (*schema.Message, error) {
-	m.turn++
-	if m.turn == 1 {
-		return &schema.Message{
-			Role:    schema.RoleAssistant,
-			Content: "让我来看看当前目录下有什么文件。",
-			ToolCalls: []schema.ToolCall{
-				{ID: "call_123", Name: "bash", Arguments: []byte(`{"command": "ls -la"}`)},
-			},
-		}, nil
-	}
-
-	return &schema.Message{
-		Role:    schema.RoleAssistant,
-		Content: "我看到了文件列表，里面包含 main.go，任务完成！",
-	}, nil
-}
-
-// ==========================================
-// 2. 伪造的 Tool Registry
-// ==========================================
-type mockRegistry struct{}
-
-func (m *mockRegistry) GetAvailableTools() []schema.ToolDefinition { return nil }
-
-func (m *mockRegistry) Execute(ctx context.Context, call schema.ToolCall) schema.ToolResult {
-	// 直接返回一段伪造的终端输出
-	return schema.ToolResult{
-		ToolCallID: call.ID,
-		Output:     "-rw-r--r--  1 user group  234 Oct 24 10:00 main.go\n",
-		IsError:    false,
-	}
-}
-
-// ==========================================
-// 3. 组装运行
-// ==========================================
 func main() {
-	// 获取当前执行目录作为 WorkDir 物理边界
+
 	workDir, _ := os.Getwd()

-	p := &mockProvider{}
-	r := &mockRegistry{}
+	// 1. 初始化真实的 Provider大脑
+	// 这里你可以任意切换 NewZhipuClaudeProvider 或 NewZhipuOpenAIProvider，效果完全一致！
+	llmProvider := provider.DeepseekOpenAIProvider("deepseek-v4-flash")

-	// 实例化核心引擎
-	eng := engine.NewAgentEngine(p, r, workDir)
+	registry := tools.NewRegistry()

-	// 发起任务指令
-	err := eng.Run(context.Background(), "帮我检查当前目录的文件")
+	// 挂载工具全家桶
+	registry.Register(tools.NewReadFileTool(workDir))
+	registry.Register(tools.NewWriteFileTool(workDir))
+	registry.Register(tools.NewBashTool(workDir))
+	registry.Register(tools.NewEditFileTool(workDir))
+	registry.Register(tools.NewReadSkillTool(workDir))
+
+	// 实例化引擎，开启 EnableThinking = true
+	eng := engine.NewAgentEngine(llmProvider, registry, workDir, false)
+
+	// 发起一个需要局部修改的指令
+	//prompt := `
+	//我当前目录下有一个 server.go 文件。
+	//请帮我把里面 "TODO: 增加鉴权逻辑" 下面的那个 if 语句，整个替换为：
+	//if user == nil {
+	//    fmt.Println("Forbidden!")
+	//    return
+	//}
+	//`
+
+	//prompt := `
+	//我当前目录下有 a.txt, b.txt, c.txt 三个文件。
+	//为了节省时间，请你同时一次性读取这三个文件，并将它们的内容综合起来，告诉我它们分别记录了什么领域的信息。
+	//`
+
+	prompt := `我需要在当前目录下新建一个 ping.go，提供一个简单的 http ping 接口。写完之后，帮我把代码用 git 提交一下。`
+
+	err := eng.Run(context.Background(), prompt)
 	if err != nil {
-		log.Fatalf("引擎崩溃: %v", err)
+		log.Fatalf("引擎运行崩溃: %v", err)
 	}
 }
@@ -1,3 +1,24 @@
 module go-tiny-claw

-go 1.24
+go 1.23.0
+
+require (
+	github.com/anthropics/anthropic-sdk-go v1.43.0
+	github.com/openai/openai-go/v3 v3.35.0
+	golang.org/x/text v0.27.0
+)
+
+require (
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
+	github.com/buger/jsonparser v1.1.2 // indirect
+	github.com/invopop/jsonschema v0.13.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/standard-webhooks/standard-webhooks/libraries v0.0.1 // indirect
+	github.com/tidwall/gjson v1.18.0 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
+	github.com/tidwall/sjson v1.2.5 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
+	golang.org/x/sync v0.16.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
@@ -0,0 +1,45 @@
+github.com/anthropics/anthropic-sdk-go v1.43.0 h1:ShY3C7lafzHP0ze1dCxL3ZFZzvkGfXJN91DfZTG8zLM=
+github.com/anthropics/anthropic-sdk-go v1.43.0/go.mod h1:5cEaslQ6A9ajdL5YUvhNW57LKxEz0OAZ7WEzgZWLD7k=
+github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
+github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
+github.com/buger/jsonparser v1.1.2 h1:frqHqw7otoVbk5M8LlE/L7HTnIq2v9RX6EJ48i9AxJk=
+github.com/buger/jsonparser v1.1.2/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dnaeon/go-vcr v1.2.0 h1:zHCHvJYTMh1N7xnV7zf1m1GPBF9Ad0Jk/whtQ1663qI=
+github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
+github.com/invopop/jsonschema v0.13.0 h1:KvpoAJWEjR3uD9Kbm2HWJmqsEaHt8lBUpd0qHcIi21E=
+github.com/invopop/jsonschema v0.13.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
+github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/openai/openai-go/v3 v3.35.0 h1:109x3epXMSE423KW2euR506GGFezcEt0s87MoWejpH0=
+github.com/openai/openai-go/v3 v3.35.0/go.mod h1:cdufnVK14cWcT9qA1rRtrXx4FTRsgbDPW7Ia7SS5cZo=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/standard-webhooks/standard-webhooks/libraries v0.0.1 h1:uOfcYT+3QungH6tIGSVCR/Y3KJmgJiHcojJbMTPDZAI=
+github.com/standard-webhooks/standard-webhooks/libraries v0.0.1/go.mod h1:L1MQhA6x4dn9r007T033lsaZMv9EmBAdXyU/+EF40fo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
+github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
+github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
+github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
+github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
+golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -4,7 +4,9 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"sync"

+	"go-tiny-claw/internal/prompt"
 	"go-tiny-claw/internal/provider"
 	"go-tiny-claw/internal/schema"
 	"go-tiny-claw/internal/tools"
@@ -17,91 +19,178 @@ type AgentEngine struct {

 	// WorkDir (工作区): 借鉴 OpenClaw 的理念，Agent 必须有一个明确的物理边界
 	WorkDir        string
+	EnableThinking bool // 【新增】慢思考模式开关
+	composer       *prompt.PromptComposer
 }

-func NewAgentEngine(p provider.LLMProvider, r tools.Registry, workDir string) *AgentEngine {
+func NewAgentEngine(p provider.LLMProvider, r tools.Registry, workDir string, enableThinking bool) *AgentEngine {
 	return &AgentEngine{
 		provider:       p,
 		registry:       r,
 		WorkDir:        workDir,
+		EnableThinking: enableThinking,
+		composer:       prompt.NewPromptComposer(workDir),
+	}
+}
+
+func (e *AgentEngine) String() string {
+	return fmt.Sprintf("AgentEngine{workDir: %s, thinking: %v, registry: %s}", e.WorkDir, e.EnableThinking, e.registry)
+}
+
+// dumpMessages 打印当前上下文中的所有消息 (调试用)
+func dumpMessages(msgs []schema.Message) {
+	for i, msg := range msgs {
+		content := msg.Content
+		// if len(content) > 80 {
+		// 	content = content[:80] + "..."
+		// }
+		log.Printf("  [%02d] %-10s | %s", i, msg.Role, content)
+	}
+}
+
+// dumpTools 打印当前可用的工具列表
+func dumpTools(tools []schema.ToolDefinition) {
+	if len(tools) == 0 {
+		log.Printf("  [Tools] (无可用工具)\n")
+		return
+	}
+	for i, t := range tools {
+		log.Printf("  [Tool %d] %s — %s", i, t.Name, t.Description)
 	}
 }

-// Run 启动 Agent 的生命周期
 func (e *AgentEngine) Run(ctx context.Context, userPrompt string) error {
 	log.Printf("[Engine] 引擎启动，锁定工作区: %s\n", e.WorkDir)
+	log.Printf("[Engine] 慢思考模式 (Thinking Phase): %v\n", e.EnableThinking)
+
+	systemMsg := e.composer.Build()

-	// 1. 初始化会话的 Context (上下文内存)
-	// 在真实的场景中，这里会由动态 Prompt 组装器加载 AGENTS.md。目前我们先硬编码。
 	contextHistory := []schema.Message{
-		{
-			Role:    schema.RoleSystem,
-			Content: "You are go-tiny-claw, an expert coding assistant. You have full access to tools in the workspace.",
-		},
-		{
-			Role:    schema.RoleUser,
-			Content: userPrompt,
-		},
+		systemMsg, // 注入动态组装的内核、AGENTS.md 与 Skills
+		{Role: schema.RoleUser, Content: userPrompt},
 	}

 	turnCount := 0
+	const maxTurns = 10

-	// 2. The Main Loop: 心跳开始 (标准的 ReAct 循环)
 	for {
 		turnCount++
-		log.Printf("========== [Turn %d] 开始 ==========\n", turnCount)
+		if turnCount > maxTurns {
+			log.Printf("[Engine] 已达最大轮数 (%d)，强制终止。\n", maxTurns)
+			break
+		}
+		log.Printf("\n========== [Turn %d] 开始 ==========\n", turnCount)
+		dumpMessages(contextHistory)

 		// 获取当前挂载的所有工具定义
 		availableTools := e.registry.GetAvailableTools()
+		dumpTools(availableTools)

-		// 向大模型发起推理请求 (包含 Reasoning)
-		log.Println("[Engine] 正在思考 (Reasoning)...")
-		responseMsg, err := e.provider.Generate(ctx, contextHistory, availableTools)
+		// ====================================================================
+		// Phase 1: 慢思考阶段 (Thinking) - 仅第一轮执行初始规划
+		// ====================================================================
+		if e.EnableThinking && turnCount == 1 {
+			log.Println("[Engine][Phase 1] 剥夺工具访问权，强制进入慢思考与规划阶段...")
+
+			// 核心机制：传入的 availableTools 为 nil！
+			// 大模型看不到任何 JSON Schema，被迫只能输出纯文本的思考过程。
+			thinkResp, err := e.provider.Generate(ctx, contextHistory, nil)
 			if err != nil {
-			return fmt.Errorf("模型生成失败: %w", err)
+				return fmt.Errorf("Thinking 阶段生成失败: %w", err)
 			}

-		// 将模型的响应完整追加到上下文历史中
-		contextHistory = append(contextHistory, *responseMsg)
-
-		// 如果模型回复了纯文本，打印出来 (这通常是它的思考过程，或是最终结果)
-		if responseMsg.Content != "" {
-			fmt.Printf("🤖 模型: %s\n", responseMsg.Content)
+			// 如果模型输出了思考过程，我们将其作为 Assistant 消息追加到上下文中
+			if thinkResp.Content != "" {
+				fmt.Printf("🧠 [内部思考 Trace]: %s\n", thinkResp.Content)
+				contextHistory = append(contextHistory, *thinkResp)
 			}

-		// 3. 退出条件判断
-		// 如果模型没有请求任何工具调用，说明它认为任务已经完成，跳出循环。
-		if len(responseMsg.ToolCalls) == 0 {
-			log.Println("[Engine] 任务完成，退出循环。")
+			// 插入过渡指令：让模型知道现在可以调用工具了
+			contextHistory = append(contextHistory, schema.Message{
+				Role:    schema.RoleUser,
+				Content: "根据你的推理，现在请使用可用的工具来完成任务。执行具体行动。",
+			})
+		}
+
+		// ====================================================================
+		// Phase 2: 行动阶段 (Action) - 恢复工具，顺着规划执行
+		// ====================================================================
+		log.Println("[Engine][Phase 2] 恢复工具挂载，等待模型采取行动...")
+
+		// 此时的 contextHistory 中已经包含了上一阶段模型自己的 Thinking Trace + 过渡指令。
+		// 模型会顺着自己的逻辑，结合恢复的 availableTools 发起精准的工具调用。
+		actionResp, err := e.provider.Generate(ctx, contextHistory, availableTools)
+		if err != nil {
+			return fmt.Errorf("Action 阶段生成失败: %w", err)
+		}
+
+		contextHistory = append(contextHistory, *actionResp)
+
+		if actionResp.Content != "" {
+			fmt.Printf("🤖 [对外回复]: %s\n", actionResp.Content)
+		}
+
+		// ====================================================================
+		// 退出与执行逻辑 (与上一讲保持一致)
+		// ====================================================================
+		if len(actionResp.ToolCalls) == 0 {
+			log.Println("[Engine] 模型未请求调用工具，任务宣告完成。")
 			break
 		}

-		// 4. 执行行动 (Action) 与 获取观察结果 (Observation)
-		log.Printf("[Engine] 模型请求调用 %d 个工具...\n", len(responseMsg.ToolCalls))
+		log.Printf("[Engine] 模型请求并发调用 %d 个工具...\n", len(actionResp.ToolCalls))

-		for _, toolCall := range responseMsg.ToolCalls {
-			log.Printf("  -> 🛠️ 执行工具: %s, 参数: %s\n", toolCall.Name, string(toolCall.Arguments))
+		// 【核心改造开始】: 从串行 (Sequential) 演进为并行 (Parallel)

-			// 通过 Registry 路由并执行底层工具
-			result := e.registry.Execute(ctx, toolCall)
+		// 1. 预分配一个固定长度的切片，用于安全地存放各个并发工具的执行结果（Observation）
+		// 长度与 ToolCalls 的数量完全一致
+		observationMsgs := make([]schema.Message, len(actionResp.ToolCalls))
+
+		// 2. 声明 WaitGroup 用于阻塞等待所有协程完成
+		var wg sync.WaitGroup
+
+		// 3. 遍历模型请求的所有工具，为每一个工具单独 Fork 出一个 Goroutine
+		for i, toolCall := range actionResp.ToolCalls {
+			wg.Add(1) // 增加计数器
+
+			// 开启协程。注意：一定要将索引 i 和 toolCall 作为参数传入匿名函数，防止闭包变量捕获陷阱！
+			go func(idx int, call schema.ToolCall) {
+				defer wg.Done() // 协程结束时计数器减一
+
+				log.Printf("  -> [Go-%d] 🛠️ 触发并行执行: %s\n", idx, call.Name)
+
+				// 调用底层 Registry 执行工具（物理操作）
+				result := e.registry.Execute(ctx, call)

 				if result.IsError {
-				log.Printf("  -> ❌ 工具执行报错: %s\n", result.Output)
+					log.Printf("  -> [Go-%d] ❌ 工具执行报错: %s\n", idx, result.Output)
 				} else {
-				log.Printf("  -> ✅ 工具执行成功 (返回 %d 字节)\n", len(result.Output))
+					log.Printf("  -> [Go-%d] ✅ 工具执行成功 (返回 %d 字节)\n", idx, len(result.Output))
 				}

-			// 将工具执行的观察结果 (Observation) 封装为 User Message 追加到上下文中
-			// 注意：ToolCallID 必须携带！这是维系大模型推理链条的关键
-			observationMsg := schema.Message{
+				// 将执行结果封装为一条用户消息 (RoleUser)
+				obsMsg := schema.Message{
 					Role:       schema.RoleUser,
 					Content:    result.Output,
-				ToolCallID: toolCall.ID,
-			}
-			contextHistory = append(contextHistory, observationMsg)
+					ToolCallID: call.ID,
 				}

-		// 循环回到开头，模型将带着新加入的 Observation 继续它的下一轮思考...
+				// 【线程安全】: 由于每个 Goroutine 操作的是预分配切片的不同索引，
+				// 这里不需要加锁 (Mutex)，性能极高！
+				observationMsgs[idx] = obsMsg
+
+			}(i, toolCall) // 闭包传参
+		}
+
+		// 4. Join 阻塞等待：主循环挂起，直到所有的并发协程全部执行完毕
+		wg.Wait()
+		log.Println("[Engine] 所有并发工具执行完毕，开始聚合观察结果 (Observation)...")
+
+		// 5. 聚合装填：将并行的结果，按照原本的顺序，一次性追加到上下文时间线中
+		// 这等价于 contextHistory = append(contextHistory, observationMsgs...)
+		for _, obs := range observationMsgs {
+			contextHistory = append(contextHistory, obs)
+		}
 	}

 	return nil
@@ -0,0 +1,68 @@
+package prompt
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"go-tiny-claw/internal/schema"
+)
+
+// PromptComposer 负责根据工作区环境动态生成 System Prompt
+type PromptComposer struct {
+	workDir     string
+	skillLoader *SkillLoader
+}
+
+func NewPromptComposer(workDir string) *PromptComposer {
+	return &PromptComposer{
+		workDir:     workDir,
+		skillLoader: NewSkillLoader(workDir),
+	}
+}
+
+// Build 组装并返回一条完整的 RoleSystem 消息
+func (c *PromptComposer) Build() schema.Message {
+	var promptBuilder strings.Builder
+
+	// 1. 极简内核 (Minimal Core)
+	promptBuilder.WriteString(`# 核心身份
+你名叫 go-tiny-claw，一个由驾驭工程驱动的骨灰级研发助手。
+你具备极简主义哲学，拒绝废话。你能通过系统提供的内置工具，创建、读取、修改和执行工作区中的代码。
+
+# 核心纪律 (CRITICAL)
+1. 如需检查文件是否存在，请使用 bash 的 ls 或 test -f，而不是对目录使用 read_file。
+2. 创建新文件时，务必使用 write_file，并同时提供 path 和 content 参数。
+3. 编辑文件前务必先读取现有文件，以理解上下文。
+4. 无论何时你需要写代码或创建文件，都要直接使用 write_file 工具。
+5. 遇到工具执行报错时，仔细阅读 stderr，尝试自己修正命令并重试。
+6. 始终用中文回复，以便传达你的进展和想法。
+`)
+
+	// 2. 外部化状态：加载项目专属规范 (AGENTS.md)
+	agentsMDPath := filepath.Join(c.workDir, "AGENTS.md")
+	content, err := os.ReadFile(agentsMDPath)
+	if err == nil {
+		promptBuilder.WriteString("\n# 项目专属指南 (来自 AGENTS.md)\n")
+		promptBuilder.WriteString("以下是当前工作区特有的架构规范与注意事项，你的行为必须绝对符合以下要求：\n")
+		promptBuilder.WriteString("```markdown\n")
+		promptBuilder.WriteString(string(content))
+		promptBuilder.WriteString("\n```\n")
+	}
+
+	// 3. 渐进式技能发现：仅注入目录（名称 + 触发条件），正文按需加载
+	skills := c.skillLoader.List()
+	if len(skills) > 0 {
+		promptBuilder.WriteString("\n# 可用专业技能\n")
+		promptBuilder.WriteString("你在以下场景可以调用 read_skill 加载完整的技能指令：\n\n")
+		for _, s := range skills {
+			promptBuilder.WriteString("- **" + s.Name + "**：" + s.Description + "\n")
+		}
+		promptBuilder.WriteString("\n当任务匹配上述技能的描述时，请先调用 read_skill 加载完整的执行指南，再严格按照指南操作。\n")
+	}
+
+	return schema.Message{
+		Role:    schema.RoleSystem,
+		Content: promptBuilder.String(),
+	}
+}
@@ -0,0 +1,128 @@
+package prompt
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Skill 定义了从 SKILL.md 中解析出的标准化技能结构
+type Skill struct {
+	Name        string
+	Description string
+	Body        string
+}
+
+// SkillSummary 是技能的轻量目录项（仅元信息，不含 Body）
+type SkillSummary struct {
+	Name        string
+	Description string
+}
+
+// SkillLoader 负责从本地文件系统中加载技能模板
+type SkillLoader struct {
+	workDir string
+}
+
+func NewSkillLoader(workDir string) *SkillLoader {
+	return &SkillLoader{workDir: workDir}
+}
+
+// List 扫描 skills 目录，返回所有技能的轻量目录（仅名称和描述）
+func (s *SkillLoader) List() []SkillSummary {
+	skillBaseDir := filepath.Join(s.workDir, "skills")
+	if _, err := os.Stat(skillBaseDir); os.IsNotExist(err) {
+		return nil
+	}
+
+	var summaries []SkillSummary
+
+	filepath.WalkDir(skillBaseDir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		if d.IsDir() || d.Name() != "SKILL.md" {
+			return nil
+		}
+
+		content, err := os.ReadFile(path)
+		if err != nil {
+			return nil
+		}
+
+		skill := parseSkillMD(string(content))
+		summaries = append(summaries, SkillSummary{
+			Name:        skill.Name,
+			Description: skill.Description,
+		})
+		return nil
+	})
+
+	return summaries
+}
+
+// Load 按技能名称加载完整的 Skill（含 Body）
+func (s *SkillLoader) Load(name string) (*Skill, error) {
+	skillBaseDir := filepath.Join(s.workDir, "skills")
+	if _, err := os.Stat(skillBaseDir); os.IsNotExist(err) {
+		return nil, fmt.Errorf("skills 目录不存在")
+	}
+
+	var found *Skill
+
+	filepath.WalkDir(skillBaseDir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil || found != nil {
+			return nil
+		}
+		if d.IsDir() || d.Name() != "SKILL.md" {
+			return nil
+		}
+
+		content, err := os.ReadFile(path)
+		if err != nil {
+			return nil
+		}
+
+		skill := parseSkillMD(string(content))
+		if skill.Name == name {
+			found = &skill
+		}
+		return nil
+	})
+
+	if found == nil {
+		return nil, fmt.Errorf("未找到技能: %s", name)
+	}
+	return found, nil
+}
+
+// parseSkillMD 解析带有 YAML Frontmatter 的 Markdown 内容
+func parseSkillMD(content string) Skill {
+	skill := Skill{
+		Name:        "Unknown Skill",
+		Description: "No description provided.",
+		Body:        content,
+	}
+
+	if strings.HasPrefix(content, "---\n") || strings.HasPrefix(content, "---\r\n") {
+		parts := strings.SplitN(content, "---", 3)
+		if len(parts) == 3 {
+			frontmatter := parts[1]
+			skill.Body = strings.TrimSpace(parts[2])
+
+			lines := strings.Split(frontmatter, "\n")
+			for _, line := range lines {
+				line = strings.TrimSpace(line)
+				if strings.HasPrefix(line, "name:") {
+					skill.Name = strings.TrimSpace(strings.TrimPrefix(line, "name:"))
+				} else if strings.HasPrefix(line, "description:") {
+					skill.Description = strings.TrimSpace(strings.TrimPrefix(line, "description:"))
+				}
+			}
+		}
+	}
+
+	return skill
+}
@@ -0,0 +1,144 @@
+// internal/provider/claude.go
+package provider
+
+import (
+    "context"
+    "encoding/json"
+    "fmt"
+    // "os"
+
+    "github.com/anthropics/anthropic-sdk-go"
+    "github.com/anthropics/anthropic-sdk-go/option"
+    "go-tiny-claw/internal/schema"
+)
+
+type ClaudeProvider struct {
+    client anthropic.Client
+    model  string
+}
+
+func DeepseekClaudeProvider(model string) *ClaudeProvider {
+	apiKey := "sk-1f44696abe644bd684f09cc43f12c557"
+    if apiKey == "" {
+        panic("请设置 ZHIPU_API_KEY 环境变量")
+    }
+    baseURL := "https://api.deepseek.com/anthropic"
+    return &ClaudeProvider{
+        client: anthropic.NewClient(option.WithAPIKey(apiKey), option.WithBaseURL(baseURL)),
+        model:  model,
+    }
+}
+
+func (p *ClaudeProvider) Generate(ctx context.Context, msgs []schema.Message, availableTools []schema.ToolDefinition) (*schema.Message, error) {
+    var anthropicMsgs []anthropic.MessageParam
+    var systemPrompt string
+
+    // 1. 消息翻译
+    for _, msg := range msgs {
+        switch msg.Role {
+        case schema.RoleSystem:
+            systemPrompt = msg.Content
+        case schema.RoleUser:
+            if msg.ToolCallID != "" {
+                anthropicMsgs = append(anthropicMsgs, anthropic.NewUserMessage(
+                    anthropic.NewToolResultBlock(msg.ToolCallID, msg.Content, false),
+                ))
+            } else {
+                anthropicMsgs = append(anthropicMsgs, anthropic.NewUserMessage(
+                    anthropic.NewTextBlock(msg.Content),
+                ))
+            }
+        case schema.RoleAssistant:
+            var blocks []anthropic.ContentBlockParamUnion
+            if msg.Content != "" {
+                blocks = append(blocks, anthropic.NewTextBlock(msg.Content))
+            }
+
+            // 将历史工具调用转回 Claude 特有的 ToolUseBlockParam
+            for _, tc := range msg.ToolCalls {
+                var inputMap map[string]interface{}
+                _ = json.Unmarshal(tc.Arguments, &inputMap)
+                blocks = append(blocks, anthropic.ContentBlockParamUnion{
+                    OfToolUse: &anthropic.ToolUseBlockParam{
+                        ID:    tc.ID,
+                        Name:  tc.Name,
+                        Input: inputMap,
+                    },
+                })
+            }
+            if len(blocks) > 0 {
+                anthropicMsgs = append(anthropicMsgs, anthropic.NewAssistantMessage(blocks...))
+            }
+        }
+    }
+
+    // 2. 工具 Schema 翻译
+    var anthropicTools []anthropic.ToolUnionParam
+    for _, toolDef := range availableTools {
+        // ToolInputSchemaParam 是结构体，需要通过 Properties 字段精准填充
+        var properties map[string]any
+        var required []string
+
+        if m, ok := toolDef.InputSchema.(map[string]interface{}); ok {
+            if p, ok := m["properties"].(map[string]interface{}); ok {
+                properties = p
+            }
+            if r, ok := m["required"].([]string); ok {
+                required = r
+            }
+        }
+
+        tp := anthropic.ToolParam{
+            Name:        toolDef.Name,
+            Description: anthropic.String(toolDef.Description),
+            InputSchema: anthropic.ToolInputSchemaParam{
+                Properties: properties,
+                Required:   required,
+            },
+        }
+        anthropicTools = append(anthropicTools, anthropic.ToolUnionParam{OfTool: &tp})
+    }
+
+    // 3. 构建请求并发送
+    params := anthropic.MessageNewParams{
+        Model:     anthropic.Model(p.model),
+        MaxTokens: 4096,
+        Messages:  anthropicMsgs,
+    }
+
+    if systemPrompt != "" {
+        params.System = []anthropic.TextBlockParam{
+            {Text: systemPrompt},
+        }
+    }
+
+    if len(anthropicTools) > 0 {
+        params.Tools = anthropicTools
+    }
+
+    resp, err := p.client.Messages.New(ctx, params)
+    if err != nil {
+        return nil, fmt.Errorf("Claude/Zhipu API 请求失败: %w", err)
+    }
+
+    // 4. 反向解析
+    resultMsg := &schema.Message{
+        Role: schema.RoleAssistant,
+    }
+
+    for _, block := range resp.Content {
+        switch block.Type {
+        case "text":
+            resultMsg.Content += block.Text
+        case "tool_use":
+            argsBytes, _ := json.Marshal(block.Input)
+            resultMsg.ToolCalls = append(resultMsg.ToolCalls, schema.ToolCall{
+                ID:        block.ID,
+                Name:      block.Name,
+                Arguments: argsBytes,
+            })
+        }
+    }
+
+    return resultMsg, nil
+}
@@ -0,0 +1,213 @@
+// internal/provider/openai.go
+package provider
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+
+	// "os"
+
+	"go-tiny-claw/internal/schema"
+
+	"github.com/openai/openai-go/v3"
+	"github.com/openai/openai-go/v3/option"
+	"github.com/openai/openai-go/v3/packages/param"
+	"github.com/openai/openai-go/v3/shared"
+)
+
+type OpenAIProvider struct {
+	client openai.Client // 值类型，非指针
+	model  string
+}
+
+// NewZhipuOpenAIProvider 构造函数：基于 OpenAI V3 SDK，指向智谱底座
+func DeepseekOpenAIProvider(model string) *OpenAIProvider {
+	apiKey := "sk-1f44696abe644bd684f09cc43f12c557"
+	if apiKey == "" {
+		panic("请设置 ZHIPU_API_KEY 环境变量")
+	}
+	// 核心：将官方 SDK 的地址替换为智谱的兼容端点
+	baseURL := "https://api.deepseek.com"
+
+	return &OpenAIProvider{
+		client: openai.NewClient(option.WithAPIKey(apiKey), option.WithBaseURL(baseURL)),
+		model:  model,
+	}
+}
+
+func (p *OpenAIProvider) Generate(ctx context.Context, msgs []schema.Message, availableTools []schema.ToolDefinition) (*schema.Message, error) {
+	phase := "Action"
+	if len(availableTools) == 0 {
+		phase = "Thinking"
+	}
+	log.Printf("[Provider] → API 调用 | 模型: %s | 阶段: %s | 消息数: %d | 工具数: %d",
+		p.model, phase, len(msgs), len(availableTools))
+
+	var openaiMsgs []openai.ChatCompletionMessageParamUnion
+
+	// 1. 翻译上下文消息
+	for _, msg := range msgs {
+		switch msg.Role {
+		case schema.RoleSystem:
+			openaiMsgs = append(openaiMsgs, openai.SystemMessage(msg.Content))
+
+		case schema.RoleUser:
+			if msg.ToolCallID != "" {
+				// 注意：v3 新版参数顺序是 (content, toolCallID)
+				openaiMsgs = append(openaiMsgs, openai.ToolMessage(msg.Content, msg.ToolCallID))
+			} else {
+				openaiMsgs = append(openaiMsgs, openai.UserMessage(msg.Content))
+			}
+
+		case schema.RoleAssistant:
+			// Deepseek thinking mode: reasoning_content 必须回传
+			if msg.ReasoningContent != "" || len(msg.ToolCalls) > 0 {
+				msgMap := map[string]interface{}{
+					"role":    "assistant",
+					"content": msg.Content,
+				}
+				if msg.ReasoningContent != "" {
+					msgMap["reasoning_content"] = msg.ReasoningContent
+				}
+				if len(msg.ToolCalls) > 0 {
+					var toolCalls []map[string]interface{}
+					for _, tc := range msg.ToolCalls {
+						toolCalls = append(toolCalls, map[string]interface{}{
+							"id":   tc.ID,
+							"type": "function",
+							"function": map[string]interface{}{
+								"name":      tc.Name,
+								"arguments": string(tc.Arguments),
+							},
+						})
+					}
+					msgMap["tool_calls"] = toolCalls
+				}
+				rawJSON, _ := json.Marshal(msgMap)
+				astParam := param.Override[openai.ChatCompletionAssistantMessageParam](json.RawMessage(rawJSON))
+				openaiMsgs = append(openaiMsgs, openai.ChatCompletionMessageParamUnion{
+					OfAssistant: &astParam,
+				})
+				break
+			}
+
+			astParam := openai.ChatCompletionAssistantMessageParam{}
+
+			if msg.Content != "" {
+				astParam.Content = openai.ChatCompletionAssistantMessageParamContentUnion{
+					OfString: openai.String(msg.Content),
+				}
+			}
+
+			// 【重要】如果历史包含 ToolCalls，必须原样放回，以维系大模型的逻辑链
+			if len(msg.ToolCalls) > 0 {
+				var toolCalls []openai.ChatCompletionMessageToolCallUnionParam
+				for _, tc := range msg.ToolCalls {
+					// OfFunction 对应 GetFunction()，字段类型严格要求为指针
+					toolCalls = append(toolCalls, openai.ChatCompletionMessageToolCallUnionParam{
+						OfFunction: &openai.ChatCompletionMessageFunctionToolCallParam{
+							ID:   tc.ID,
+							Type: "function",
+							Function: openai.ChatCompletionMessageFunctionToolCallFunctionParam{
+								Name:      tc.Name,
+								Arguments: string(tc.Arguments),
+							},
+						},
+					})
+				}
+				astParam.ToolCalls = toolCalls
+			}
+
+			openaiMsgs = append(openaiMsgs, openai.ChatCompletionMessageParamUnion{
+				OfAssistant: &astParam,
+			})
+		}
+	}
+
+	// 2. 翻译工具定义 (v3 新 API 特性适配)
+	var openaiTools []openai.ChatCompletionToolUnionParam
+	for _, toolDef := range availableTools {
+		var params shared.FunctionParameters
+
+		// 尝试直接断言，如果不成功则通过 JSON 往返序列化来保证类型匹配
+		if m, ok := toolDef.InputSchema.(map[string]interface{}); ok {
+			params = shared.FunctionParameters(m)
+		} else {
+			// fallback：JSON 往返序列化
+			b, _ := json.Marshal(toolDef.InputSchema)
+			_ = json.Unmarshal(b, &params)
+		}
+
+		openaiTools = append(openaiTools, openai.ChatCompletionFunctionTool(
+			shared.FunctionDefinitionParam{
+				Name:        toolDef.Name,
+				Description: openai.String(toolDef.Description),
+				Parameters:  params,
+			},
+		))
+	}
+
+	// 3. 构建请求并发送
+	params := openai.ChatCompletionNewParams{
+		Model:    p.model,
+		Messages: openaiMsgs,
+	}
+
+	// 【慢思考机制支撑】仅当 availableTools 存在时才挂载 Tools
+	if len(openaiTools) > 0 {
+		params.Tools = openaiTools
+	}
+
+	resp, err := p.client.Chat.Completions.New(ctx, params)
+	if err != nil {
+		return nil, fmt.Errorf("OpenAI/Zhipu API 请求失败: %w", err)
+	}
+	if len(resp.Choices) == 0 {
+		return nil, fmt.Errorf("API 返回了空的 Choices")
+	}
+
+	// 4. 将 API Response 反向翻译为内部 schema.Message
+	choice := resp.Choices[0].Message
+	resultMsg := &schema.Message{
+		Role:    schema.RoleAssistant,
+		Content: choice.Content,
+	}
+
+	// Deepseek thinking mode: 从原始响应中提取 reasoning_content
+	rawMsg := choice.RawJSON()
+	if rawMsg != "" {
+		var rawMap map[string]json.RawMessage
+		if err := json.Unmarshal([]byte(rawMsg), &rawMap); err == nil {
+			if rc, ok := rawMap["reasoning_content"]; ok {
+				var s string
+				if json.Unmarshal(rc, &s) == nil {
+					resultMsg.ReasoningContent = s
+				}
+			}
+		}
+	}
+
+	for _, tc := range choice.ToolCalls {
+		if tc.Type == "function" {
+			resultMsg.ToolCalls = append(resultMsg.ToolCalls, schema.ToolCall{
+				ID:        tc.ID,
+				Name:      tc.Function.Name,
+				Arguments: []byte(tc.Function.Arguments),
+			})
+		}
+	}
+
+	// 打印响应摘要
+	contentPreview := resultMsg.Content
+	// if len(contentPreview) > 60 {
+	//     contentPreview = contentPreview[:60] + "..."
+	// }
+	log.Printf("[Provider] ← API 响应 | 内容: %q | 工具调用: %d", contentPreview, len(resultMsg.ToolCalls))
+	for _, tc := range resultMsg.ToolCalls {
+		log.Printf("[Provider]   ↳ ToolCall: %s(%s)", tc.Name, string(tc.Arguments))
+	}
+
+	return resultMsg, nil
+}
@@ -16,6 +16,9 @@ type Message struct {
 	Role    Role   `json:"role"`
 	Content string `json:"content"` // 存放纯文本内容

+	// ReasoningContent Deepseek thinking 模式的内部推理链，回传时必须保留
+	ReasoningContent string `json:"reasoning_content,omitempty"`
+
 	// 如果模型决定调用工具，此字段将被填充 (支持并行调用多个工具)
 	ToolCalls []ToolCall `json:"tool_calls,omitempty"`

@@ -0,0 +1,89 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"time"
+
+	"go-tiny-claw/internal/schema"
+)
+
+type BashTool struct {
+	workDir string // 工作区约束
+}
+
+func NewBashTool(workDir string) *BashTool {
+	return &BashTool{workDir: workDir}
+}
+
+func (t *BashTool) Name() string {
+	return "bash"
+}
+
+func (t *BashTool) Definition() schema.ToolDefinition {
+	return schema.ToolDefinition{
+		Name:        t.Name(),
+		Description: "在当前工作区执行任意的 bash 命令。支持链式命令(如 &&)。返回标准输出(stdout)和标准错误(stderr)。",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"command": map[string]interface{}{
+					"type":        "string",
+					"description": "要执行的 bash 命令，例如: ls -la 或 go test ./...",
+				},
+			},
+			"required": []string{"command"},
+		},
+	}
+}
+
+type bashArgs struct {
+	Command string `json:"command"`
+}
+
+func (t *BashTool) Execute(ctx context.Context, args json.RawMessage) (string, error) {
+	var input bashArgs
+	if err := json.Unmarshal(args, &input); err != nil {
+		return "", fmt.Errorf("参数解析失败: %w", err)
+	}
+
+	// 【驾驭底线 1】：Time Budgeting (时间预算与超时控制)
+	timeoutCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+
+	// Unix 和 Windows 统一使用 bash -c（Windows 需安装 Git Bash），编码转换在下方处理
+	cmd := exec.CommandContext(timeoutCtx, "bash", "-c", input.Command)
+
+	// 【驾驭底线 2】：绑定执行的工作区目录
+	cmd.Dir = t.workDir
+
+	// 执行并捕获 CombinedOutput (合并 stdout 和 stderr)
+	out, err := cmd.CombinedOutput()
+
+	outputStr := string(out)
+
+	// 如果命令执行超时，返回警告信息让模型知晓
+	if timeoutCtx.Err() == context.DeadlineExceeded {
+		return outputStr + "\n[警告: 命令执行超时(30s)，已被系统强制终止。如果是启动常驻服务，请尝试将其转入后台。]", nil
+	}
+
+	// 【驾驭底线 3】：错误原样回传 (Self-Correction 自愈机制)
+	if err != nil {
+		return fmt.Sprintf("执行报错: %v\n输出:\n%s", err, outputStr), nil
+	}
+
+	// 如果没有终端输出，给模型一个明确的执行成功的反馈
+	if outputStr == "" {
+		return "命令执行成功，无终端输出。", nil
+	}
+
+	// 【驾驭底线 4】：长度截断保护 (防 OOM)
+	const maxLen = 8000
+	if len(outputStr) > maxLen {
+		return fmt.Sprintf("%s\n\n...[终端输出过长，已截断至前 %d 字节]...", outputStr[:maxLen], maxLen), nil
+	}
+
+	return outputStr, nil
+}
@@ -0,0 +1,172 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go-tiny-claw/internal/schema"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type EditFileTool struct {
+	workDir string
+}
+
+func NewEditFileTool(workDir string) *EditFileTool {
+	return &EditFileTool{workDir: workDir}
+}
+
+func (t *EditFileTool) Name() string {
+	return "edit_file"
+}
+
+func (t *EditFileTool) Definition() schema.ToolDefinition {
+	return schema.ToolDefinition{
+		Name:        t.Name(),
+		Description: "对现有文件进行局部的字符串替换。这比重写整个文件更安全、更快速。请提供足够的 old_text 上下文以确保匹配的唯一性。",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "要修改的文件路径",
+				},
+				"old_text": map[string]interface{}{
+					"type":        "string",
+					"description": "文件中原有的文本。必须包含足够的上下文（建议上下各多包含几行），以确保在文件中的唯一性。",
+				},
+				"new_text": map[string]interface{}{
+					"type":        "string",
+					"description": "要替换成的新文本",
+				},
+			},
+			"required": []string{"path", "old_text", "new_text"},
+		},
+	}
+}
+
+type editFileArgs struct {
+	Path    string `json:"path"`
+	OldText string `json:"old_text"`
+	NewText string `json:"new_text"`
+}
+
+// fuzzyReplace 实现了四级容错降级替换算法
+func fuzzyReplace(originalContent, oldText, newText string) (string, error) {
+	// L1: 精确匹配
+	count := strings.Count(originalContent, oldText)
+	if count == 1 {
+		return strings.Replace(originalContent, oldText, newText, 1), nil
+	}
+	if count > 1 {
+		return "", fmt.Errorf("old_text 匹配到了 %d 处，请提供更多的上下文代码以确保唯一性", count)
+	}
+
+	// L2: 换行符归一化 (统一将 \r\n 转换为 \n)
+	normalizedContent := strings.ReplaceAll(originalContent, "\r\n", "\n")
+	normalizedOld := strings.ReplaceAll(oldText, "\r\n", "\n")
+
+	count = strings.Count(normalizedContent, normalizedOld)
+	if count == 1 {
+		return strings.Replace(normalizedContent, normalizedOld, newText, 1), nil
+	}
+
+	// L3: Trim Space 匹配 (忽略首尾的空行和空格)
+	trimmedOld := strings.TrimSpace(normalizedOld)
+	if trimmedOld != "" {
+		count = strings.Count(normalizedContent, trimmedOld)
+		if count == 1 {
+			// 注意：这里替换时，我们只能替换被 Trim 后的部分，不能直接用 newText 破坏原本的缩进
+			// 为了保持本专栏代码不过于冗长复杂，当触发 L3/L4 时，如果 newText 没有带有正确的缩进，
+			// 可能会导致替换后代码格式不美观。但这总比直接报错让 Agent 死循环要好。
+			return strings.Replace(normalizedContent, trimmedOld, newText, 1), nil
+		}
+	}
+
+	// L4: 逐行去缩进匹配 (最强力的容错：消除大模型遗漏缩进的幻觉)
+	return lineByLineReplace(normalizedContent, normalizedOld, newText)
+}
+
+// lineByLineReplace 将文本按行切割，去除首尾空白后进行滑动窗口匹配
+func lineByLineReplace(content, oldText, newText string) (string, error) {
+	contentLines := strings.Split(content, "\n")
+	oldLines := strings.Split(strings.TrimSpace(oldText), "\n")
+
+	if len(oldLines) == 0 || len(contentLines) < len(oldLines) {
+		return "", fmt.Errorf("找不到该代码片段")
+	}
+
+	// 清理 oldLines 的每行首尾空白
+	for i := range oldLines {
+		oldLines[i] = strings.TrimSpace(oldLines[i])
+	}
+
+	matchCount := 0
+	matchStartIndex := -1
+	matchEndIndex := -1
+
+	// 滑动窗口在原始文件中寻找匹配块
+	for i := 0; i <= len(contentLines)-len(oldLines); i++ {
+		isMatch := true
+		for j := 0; j < len(oldLines); j++ {
+			if strings.TrimSpace(contentLines[i+j]) != oldLines[j] {
+				isMatch = false
+				break
+			}
+		}
+
+		if isMatch {
+			matchCount++
+			matchStartIndex = i
+			matchEndIndex = i + len(oldLines)
+		}
+	}
+
+	if matchCount == 0 {
+		return "", fmt.Errorf("在文件中未找到 old_text，请大模型先调用 read_file 仔细确认文件内容和缩进")
+	}
+	if matchCount > 1 {
+		return "", fmt.Errorf("模糊匹配到了 %d 处相似代码，请提供更多上下行代码以精确定位", matchCount)
+	}
+
+	// 执行替换：将匹配到的原始行范围替换为 newText 拆分后的行
+	// (这里简单处理，将 newText 直接作为整体替换进去)
+	var newContentLines []string
+	newContentLines = append(newContentLines, contentLines[:matchStartIndex]...)
+	newContentLines = append(newContentLines, newText) // 插入新内容
+	newContentLines = append(newContentLines, contentLines[matchEndIndex:]...)
+
+	return strings.Join(newContentLines, "\n"), nil
+}
+
+func (t *EditFileTool) Execute(ctx context.Context, args json.RawMessage) (string, error) {
+	var input editFileArgs
+	if err := json.Unmarshal(args, &input); err != nil {
+		return "", fmt.Errorf("参数解析失败: %w", err)
+	}
+
+	fullPath := filepath.Join(t.workDir, input.Path)
+
+	// 1. 读取原文件内容
+	contentBytes, err := os.ReadFile(fullPath)
+	if err != nil {
+		return "", fmt.Errorf("读取文件失败，请确认路径是否正确: %w", err)
+	}
+	originalContent := string(contentBytes)
+
+	// 2. 调用多级模糊替换算法
+	newContent, err := fuzzyReplace(originalContent, input.OldText, input.NewText)
+	if err != nil {
+		// 【驾驭哲学】将具体的报错原因 (如匹配到多处) 原样返回，让大模型自行纠正
+		return "", err
+	}
+
+	// 3. 将新内容安全地写回磁盘
+	if err := os.WriteFile(fullPath, []byte(newContent), 0644); err != nil {
+		return "", fmt.Errorf("写回文件失败: %w", err)
+	}
+
+	return fmt.Sprintf("✅ 成功修改文件: %s", input.Path), nil
+}
@@ -0,0 +1,85 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"go-tiny-claw/internal/schema"
+)
+
+// ReadFileTool 实现了读取本地文件内容的工具
+type ReadFileTool struct {
+    // 将引擎的 WorkDir 注入给工具，限制它只能在此目录及其子目录下操作
+    workDir string 
+}
+
+func NewReadFileTool(workDir string) *ReadFileTool {
+    return &ReadFileTool{workDir: workDir}
+}
+
+func (t *ReadFileTool) Name() string {
+    return "read_file"
+}
+
+// Definition 向大模型清晰地描述这个工具的用途和参数格式
+func (t *ReadFileTool) Definition() schema.ToolDefinition {
+    return schema.ToolDefinition{
+        Name:        t.Name(),
+        Description: "读取指定路径的文件内容。请提供相对工作区的路径。",
+        // 遵循 JSON Schema 规范定义参数
+        InputSchema: map[string]interface{}{
+            "type": "object",
+            "properties": map[string]interface{}{
+                "path": map[string]interface{}{
+                    "type":        "string",
+                    "description": "要读取的文件路径，如 cmd/claw/main.go",
+                },
+            },
+            "required": []string{"path"},
+        },
+    }
+}
+
+// readFileArgs 内部定义用于反序列化的结构体
+type readFileArgs struct {
+    Path string `json:"path"`
+}
+
+func (t *ReadFileTool) Execute(ctx context.Context, args json.RawMessage) (string, error) {
+    // 1. 延迟解析：将大模型传过来的 JSON 参数解析为强类型结构体
+    var input readFileArgs
+    if err := json.Unmarshal(args, &input); err != nil {
+        // 返回 error 会被 Registry 捕获并传给大模型，模型会知道自己 JSON 格式写错了
+        return "", fmt.Errorf("参数解析失败: %w", err)
+    }
+
+    // 2. 拼接绝对路径 (注意：生产环境中需要做路径穿越检测防范，防止 ../../etc/passwd)
+    fullPath := filepath.Join(t.workDir, input.Path)
+
+    // 3. 执行物理 IO 操作
+    file, err := os.Open(fullPath)
+    if err != nil {
+        return "", fmt.Errorf("打开文件失败: %w", err)
+    }
+    defer file.Close()
+
+    content, err := io.ReadAll(file)
+    if err != nil {
+        return "", fmt.Errorf("读取文件内容失败: %w", err)
+    }
+
+    // 4. 【核心防线】长度截断保护
+    // 为了防止大模型读取几百 MB 的日志文件导致 Context 瞬间爆炸 (OOM)，
+    // 我们在工具内部直接进行物理截断。
+    const maxLen = 8000
+    if len(content) > maxLen {
+        truncatedMsg := fmt.Sprintf("%s\n\n...[由于内容过长，已被系统截断至前 %d 字节]...", string(content[:maxLen]), maxLen)
+        return truncatedMsg, nil
+    }
+
+    return string(content), nil
+}
@@ -0,0 +1,59 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"go-tiny-claw/internal/prompt"
+	"go-tiny-claw/internal/schema"
+)
+
+type ReadSkillTool struct {
+	loader *prompt.SkillLoader
+}
+
+func NewReadSkillTool(workDir string) *ReadSkillTool {
+	return &ReadSkillTool{
+		loader: prompt.NewSkillLoader(workDir),
+	}
+}
+
+func (t *ReadSkillTool) Name() string {
+	return "read_skill"
+}
+
+func (t *ReadSkillTool) Definition() schema.ToolDefinition {
+	return schema.ToolDefinition{
+		Name:        t.Name(),
+		Description: "按技能名称加载完整的技能指令。在开始任务前可先用 read_skill 获取该技能的详细执行指南。支持技能: git-workflow",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"name": map[string]interface{}{
+					"type":        "string",
+					"description": "要加载的技能名称，如 git-workflow",
+				},
+			},
+			"required": []string{"name"},
+		},
+	}
+}
+
+type readSkillArgs struct {
+	Name string `json:"name"`
+}
+
+func (t *ReadSkillTool) Execute(ctx context.Context, args json.RawMessage) (string, error) {
+	var input readSkillArgs
+	if err := json.Unmarshal(args, &input); err != nil {
+		return "", fmt.Errorf("参数解析失败: %w", err)
+	}
+
+	skill, err := t.loader.Load(input.Name)
+	if err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("技能: %s\n描述: %s\n\n--- 技能正文 ---\n%s", skill.Name, skill.Description, skill.Body), nil
+}
@@ -2,14 +2,103 @@ package tools

 import (
 	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+
 	"go-tiny-claw/internal/schema"
 )

-// Registry 定义了工具的注册与分发执行接口
+// BaseTool 是所有具体工具必须实现的通用接口
+type BaseTool interface {
+	// Name 返回工具的全局唯一名称 (大模型通过这个名字调用它)
+	Name() string
+
+	// Definition 返回用于提交给大模型的工具元信息和参数 JSON Schema
+	Definition() schema.ToolDefinition
+
+	// Execute 接收大模型吐出的 JSON 参数，执行具体业务逻辑
+	// 注意：参数是 json.RawMessage，反序列化由各个具体工具内部自行处理
+	Execute(ctx context.Context, args json.RawMessage) (string, error)
+}
+
+// Registry 定义了工具的注册与分发接口
 type Registry interface {
-	// GetAvailableTools 返回当前系统挂载的所有可用工具的 Schema
+	// Register 挂载一个新的工具到系统中
+	Register(tool BaseTool)
+
+	// GetAvailableTools 返回当前系统挂载的所有工具的 Schema，供 Main Loop 交给 Provider
 	GetAvailableTools() []schema.ToolDefinition

-	// Execute 实际执行模型请求的工具，并返回结果
+	// Execute 实际路由并执行模型请求的工具调用
 	Execute(ctx context.Context, call schema.ToolCall) schema.ToolResult
 }
+
+// registryImpl 是 Registry 接口的默认实现
+type registryImpl struct {
+	// 使用 map 以工具的 Name 作为 Key 进行快速 O(1) 路由查找
+	tools map[string]BaseTool
+}
+
+func NewRegistry() Registry {
+	return &registryImpl{
+		tools: make(map[string]BaseTool),
+	}
+}
+
+func (r *registryImpl) String() string {
+	var names []string
+	for name := range r.tools {
+		names = append(names, name)
+	}
+	return fmt.Sprintf("Registry{tools: %v}", names)
+}
+
+func (r *registryImpl) Register(tool BaseTool) {
+	name := tool.Name()
+	if _, exists := r.tools[name]; exists {
+		log.Printf("[Warning] 工具 '%s' 已经被注册，将被覆盖。\n", name)
+	}
+	r.tools[name] = tool
+	log.Printf("[Registry] 成功挂载工具: %s\n", name)
+}
+
+func (r *registryImpl) GetAvailableTools() []schema.ToolDefinition {
+	var defs []schema.ToolDefinition
+	for _, tool := range r.tools {
+		defs = append(defs, tool.Definition())
+	}
+	return defs
+}
+
+func (r *registryImpl) Execute(ctx context.Context, call schema.ToolCall) schema.ToolResult {
+	// 1. 路由查找：如果在注册表中找不到该工具，这是模型产生了幻觉，直接向模型抛出错误
+	tool, exists := r.tools[call.Name]
+	if !exists {
+		errMsg := fmt.Sprintf("Error: 系统中不存在名为 '%s' 的工具。", call.Name)
+		return schema.ToolResult{
+			ToolCallID: call.ID,
+			Output:     errMsg,
+			IsError:    true, // 标记为错误，模型看到后会尝试纠正
+		}
+	}
+
+	// 2. 执行工具逻辑：将原始的 JSON 字节流直接丢给具体工具
+	output, err := tool.Execute(ctx, call.Arguments)
+
+	// 3. 封装结果：将执行结果或底层物理错误封装后返回给 Main Loop
+	if err != nil {
+		errMsg := fmt.Sprintf("Error executing %s: %v", call.Name, err)
+		return schema.ToolResult{
+			ToolCallID: call.ID,
+			Output:     errMsg,
+			IsError:    true,
+		}
+	}
+
+	return schema.ToolResult{
+		ToolCallID: call.ID,
+		Output:     output,
+		IsError:    false,
+	}
+}
@@ -0,0 +1,72 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"go-tiny-claw/internal/schema"
+)
+
+type WriteFileTool struct {
+	workDir string // 工作区约束
+}
+
+func NewWriteFileTool(workDir string) *WriteFileTool {
+	return &WriteFileTool{workDir: workDir}
+}
+
+func (t *WriteFileTool) Name() string {
+	return "write_file"
+}
+
+func (t *WriteFileTool) Definition() schema.ToolDefinition {
+	return schema.ToolDefinition{
+		Name:        t.Name(),
+		Description: "创建或覆盖写入一个文件。如果目录不存在会自动创建。请提供相对于工作区的相对路径。",
+		InputSchema: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"path": map[string]interface{}{
+					"type":        "string",
+					"description": "要写入的文件路径，如 src/main.go",
+				},
+				"content": map[string]interface{}{
+					"type":        "string",
+					"description": "要写入的完整文件内容",
+				},
+			},
+			"required": []string{"path", "content"},
+		},
+	}
+}
+
+type writeFileArgs struct {
+	Path    string `json:"path"`
+	Content string `json:"content"`
+}
+
+func (t *WriteFileTool) Execute(ctx context.Context, args json.RawMessage) (string, error) {
+	var input writeFileArgs
+	if err := json.Unmarshal(args, &input); err != nil {
+		return "", fmt.Errorf("参数解析失败: %w", err)
+	}
+
+	// 【安全防线】：限制在 WorkDir 下执行，防止大模型修改系统级文件
+	fullPath := filepath.Join(t.workDir, input.Path)
+
+	// 自动创建缺失的父级目录
+	if err := os.MkdirAll(filepath.Dir(fullPath), 0755); err != nil {
+		return "", fmt.Errorf("创建父目录失败: %w", err)
+	}
+
+	// 写入文件内容，权限设为 0644
+	err := os.WriteFile(fullPath, []byte(input.Content), 0644)
+	if err != nil {
+		return "", fmt.Errorf("写入文件失败: %w", err)
+	}
+
+	return fmt.Sprintf("成功将内容写入到文件: %s", input.Path), nil
+}
@@ -1,21 +1,62 @@
 package main

 import (
-	"fmt"
+	"context"
+	"log"
+	"os"
+
+	"go-tiny-claw/internal/engine"
+	"go-tiny-claw/internal/schema"
+	"go-tiny-claw/internal/tools"
 )

-//TIP <p>To run your code, right-click the code and select <b>Run</b>.</p> <p>Alternatively, click
-// the <icon src="AllIcons.Actions.Execute"/> icon in the gutter and select the <b>Run</b> menu item from here.</p>
+// mockProvider 模拟大模型推理
+type mockProvider struct {
+	turn int
+}

-func main() {
-	//TIP <p>Press <shortcut actionId="ShowIntentionActions"/> when your caret is at the underlined text
-	// to see how GoLand suggests fixing the warning.</p><p>Alternatively, if available, click the lightbulb to view possible fixes.</p>
-	s := "gopher"
-	fmt.Printf("Hello and welcome, %s!\n", s)
+func (m *mockProvider) Generate(ctx context.Context, msgs []schema.Message, _ []schema.ToolDefinition) (*schema.Message, error) {
+	m.turn++
+	if m.turn == 1 {
+		return &schema.Message{
+			Role:    schema.RoleAssistant,
+			Content: "让我来看看当前目录下有什么文件。",
+			ToolCalls: []schema.ToolCall{
+				{ID: "call_123", Name: "bash", Arguments: []byte(`{"command": "ls -la"}`)},
+			},
+		}, nil
+	}
+	return &schema.Message{
+		Role:    schema.RoleAssistant,
+		Content: "我看到了文件列表，里面包含 main.go，任务完成！",
+	}, nil
+}

-	for i := 1; i <= 5; i++ {
-		//TIP <p>To start your debugging session, right-click your code in the editor and select the Debug option.</p> <p>We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-		// for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.</p>
-		fmt.Println("i =", 100/i)
+// mockRegistry 模拟工具执行
+type mockRegistry struct{}
+
+func (m *mockRegistry) GetAvailableTools() []schema.ToolDefinition { return nil }
+
+func (m *mockRegistry) Register(tool tools.BaseTool) {}
+
+func (m *mockRegistry) Execute(ctx context.Context, call schema.ToolCall) schema.ToolResult {
+	return schema.ToolResult{
+		ToolCallID: call.ID,
+		Output:     "-rw-r--r--  1 user group  234 Oct 24 10:00 main.go\n",
+		IsError:    false,
+	}
+}
+
+func main() {
+	workDir, _ := os.Getwd()
+
+	p := &mockProvider{}
+	r := &mockRegistry{}
+
+	eng := engine.NewAgentEngine(p, r, workDir, true)
+
+	err := eng.Run(context.Background(), "帮我检查当前目录的文件")
+	if err != nil {
+		log.Fatalf("引擎崩溃: %v", err)
 	}
 }
@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	// 启动服务器
+	fmt.Println("Server is starting on port 8080...")
+
+	// TODO: 增加鉴权逻辑
+	if user == nil {
+		fmt.Println("Forbidden!")
+		return
+	}
+}
@@ -0,0 +1,10 @@
+---
+name: git-workflow
+description: 当人类用户要求你“提交代码”、“保存变更”或执行 Git 相关操作时，必须使用此技能。
+---
+
+# 提交流程 SOP
+
+1. 先使用 `bash` 调用 `git status` 确认当前有哪些文件发生了改动。
+2. 你的 commit message 必须使用 Emoji 开头，例如：`🚀 feat: 增加新功能` 或 `🐛 fix: 修复 Bug`。
+3. 严禁使用 `git commit -am "update"` 这种敷衍的提交。
Author	SHA1	Message	Date
aruo	3e91c7d0a1	v1.6 System Prompt 工程化 + 渐进式技能发现重构 system prompt 为动态组装系统：PromptComposer 聚合核心身份、AGENTS.md 项目规范和 Skills 目录；新增 read_skill 工具实现技能按需加载；包重命名 internal/context -> internal/prompt 消除 stdlib 冲突。	2026-05-17 00:05:31 +08:00
aruo	d84fdbd24e	v1.5 多工具并发执行将引擎的工具调用从串行改为并行：预分配结果切片 + sync.WaitGroup + 按索引无锁写入，模型一次请求多个工具时同时执行。	2026-05-16 23:20:03 +08:00
zhuyongxin	deb1b6e660	v1.5 Edit 工具 + 四级容错替换算法 - 新增 EditFileTool，支持局部字符串替换 - 四级容错降级：精确匹配 → 换行符归一 → Trim Space → 逐行滑动窗口 - 工具集扩展至 4 个（read/write/edit/bash） - 新增 server.go 测试目标文件	2026-05-15 18:32:57 +08:00
zhuyongxin	cefabd68dc	v1.4 工具集扩展 + Windows 编码攻坚 - 新增 BashTool（bash 命令执行，30s 超时 + 自愈 + 截断） - 新增 WriteFileTool（文件写入） - Windows GBK 编码自动转 UTF-8（golang.org/x/text） - OpenAIProvider 新增 API 交互日志 - dumpMessages 移除截断，完整展示上下文 - cmd/claw 三段式任务演示	2026-05-15 17:11:43 +08:00
zhuyongxin	b94460083a	v1.3 Registry 实现重构 + 第一把真实工具 - Registry 从纯接口升级为完整实现：Register/Execute/路由查找/错误自愈 - 新增 BaseTool 接口，统一工具契约 - 新增 ReadFileTool，首个真实工具实现（路径防穿越 + 截断保护） - 新增 String() 方法，Registry/Engine 调试可视化 - 新增 ToolCall 执行状态日志 - cmd/claw 切换为真实 Registry + ReadFileTool	2026-05-15 11:24:42 +08:00
zhuyongxin	daa89531f5	v1.2 真实模型接入 + Thinking 死循环修复 - 新增 OpenAIProvider / ClaudeProvider，接入 Deepseek 真实 API - 修复 Deepseek thinking 模式 reasoning_content 回传问题 - 修复 Thinking 阶段过渡指令每轮重复插入导致的死循环 - 新增 maxTurns 保护、dumpMessages/dumpTools 调试输出	2026-05-14 20:35:44 +08:00
zhuyongxin	f75d0c49ae	v1.1 慢思考模式 (Thinking Phase) 将 ReAct 循环从单阶段升级为 Thinking + Action 双阶段架构： - Phase 1：剥夺工具访问权，强制模型先输出纯文本推理规划 - Phase 2：恢复工具挂载，模型按推理结果精准执行 - 新增 EnableThinking 开关，兼容旧模式	2026-05-14 15:47:41 +08:00
zhuyongxin	b8459ef36c	清理 main.go 模板代码并补充 README 文档 - 移除 main.go 中的 GoLand 自动生成模板代码，替换为项目实际入口 - 补充空的 README.md，添加项目说明、架构图、模块表和快速开始指南	2026-05-14 15:36:42 +08:00