diff --git a/README.md b/README.md
index 34dbe48..746d329 100644
--- a/README.md
+++ b/README.md
@@ -1,478 +1,224 @@
# AgentForge
-> Orchestrate AI coding agents from your Mac — schedule, monitor, and chain Claude Code tasks on a kanban board.
+**A local-first macOS command center for running Claude Code and OpenAI Codex CLI as schedulable, observable tasks.**
[](LICENSE)
-[](https://github.com/releases)
-[](https://bun.sh) [](https://www.typescriptlang.org)
-[](https://docs.anthropic.com/en/docs/claude-code)
+[](../../releases)
+[](https://bun.sh)
+[](https://www.typescriptlang.org)
-**Website**: https://agentforge-landing-weld.vercel.app/
+AgentForge turns agent work into a visible local workflow: queue tasks, watch live runs, schedule recurring checks, route tasks from chat, and distill repeated patterns into reusable skills.
-
+**Website:** https://agentforge-landing-weld.vercel.app/
----
+
-## Table of Contents
+## Why AgentForge
-- [Features](#features)
-- [Skill Library](#skill-library)
-- [Requirements](#requirements)
-- [Installation](#installation)
-- [Troubleshooting](#troubleshooting)
-- [Quick Start](#quick-start)
-- [Chat Channels](#chat-channels)
-- [Multi-Agent Pipelines (DAG)](#multi-agent-pipelines-dag)
-- [API Reference](#api-reference)
-- [Background Service](#background-service)
-- [Architecture](#architecture)
-- [Contributing](#contributing)
-- [License](#license)
+- **Stop babysitting terminals.** Create tasks once, then monitor queue, running, and done states from a kanban board.
+- **Run the right agent per job.** Use Claude Code or Codex CLI on each task, with a configurable default.
+- **Make agent work repeatable.** Schedule immediate, delayed, one-time, or cron tasks, then reuse successful patterns through the Skill Library.
+- **Keep execution local.** The backend listens on `127.0.0.1`, stores state in SQLite, and runs agent CLIs on your Mac.
----
-
-## Features
-
-- **🧬 Compounding Skill Library** — AgentForge detects recurring patterns across your completed tasks and distills them — using Anthropic's [skill-creator](https://github.com/anthropics/skills/tree/main/skills/skill-creator) — into reusable Claude Code skills. Review, approve, and they're symlinked into both Claude Code and Codex. Your agents get better at *your* work over time. [Learn more →](#skill-library)
-- **Agents that spawn agents** — Any running task can create sub-tasks, build DAG pipelines, and collect results via the bundled Claude Code skill
-- **Kanban Task Board** — Visual Queue / Running / Done columns with live output streaming
-- **DAG Pipelines** — Define task dependencies with automatic cascade execution and failure propagation
-- **Flexible Scheduling** — Immediate, delayed, one-time datetime, and cron-based recurring tasks
-- **Dual Agent Backends** — Run tasks with Claude Code CLI or OpenAI Codex CLI; choose per-task or set a default
-- **Chat Control** — Create tasks and receive notifications from Telegram, Slack, Feishu/Lark, or WeChat
-- **Persistent Storage** — SQLite-backed task history, run logs, and streaming output
-- **Native macOS App** — Electron shell with one-click DMG install
-
----
-
-## Skill Library
-
-**Turn the work you repeat into skills your agents reuse — automatically.** The more you use AgentForge, the better it gets at *your* workflows.
-
-1. **Detect** — A background sweep (or the manual **Scan** button) analyzes your completed task runs and tracks recurring patterns in a cross-run ledger — both *recipes* (workflows you repeat) and *pitfalls* (failures you diagnosed and fixed). Counting is idempotent per run, so re-scanning never inflates it.
-2. **Distill** — For a pattern worth codifying, AgentForge uses Anthropic's **[skill-creator](https://github.com/anthropics/skills/tree/main/skills/skill-creator)** skill to author a proper `SKILL.md` — and first judges whether it's even *worth* a skill, so you don't drown in noise.
-3. **Approve** — Review the draft: the worthiness verdict, the contributing tasks, and a fully editable `SKILL.md`. Approve or dismiss — you stay in control.
-4. **Deliver** — Approved skills are written once to a canonical store and symlinked into **both** `~/.claude/skills` (Claude Code) and `~/.agents/skills` (Codex). Both agents load them natively via progressive disclosure — zero prompt injection.
-5. **Manage** — Enable/disable each skill (toggles the symlinks, keeps the file), view its `SKILL.md`, or delete it — all from the **Skills** tab.
-
-> The automatic daily sweep is **off by default** (it spends tokens). Flip it on in **Settings → Skill Library**, choose the agent and cadence, or just hit the manual **Scan** button whenever you like — that always works, threshold or not.
-
-Distilled skills are standard Claude Code `SKILL.md` files (canonical copy in `~/.agentforge/skills`, symlinked to each agent's native dir) — portable, inspectable, no lock-in.
-
----
-
-## Requirements
-
-- macOS 12.0+ (Apple Silicon or Intel)
-- [Bun](https://bun.sh) 1.3+
-- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and on `PATH` (default agent)
-- [OpenAI Codex CLI](https://github.com/openai/codex) on `PATH` — optional, required only if using Codex as agent backend (`npm install -g @openai/codex`)
-
----
-
-## Installation
+## Quick Start
-### Option 1: Desktop App (Recommended)
+### Install The App
-1. Download the latest `AgentForge-*.dmg` from the [Releases](../../releases) page.
-2. Open the DMG and drag **AgentForge** into `/Applications`.
-3. Launch from Launchpad or the Applications folder.
+1. Download the latest `AgentForge-*.dmg` from [Releases](../../releases).
+2. Drag **AgentForge** into `/Applications`.
+3. Launch it, choose a working directory, and create your first task.
-### Option 2: Build from Source
+### Run From Source
```bash
-git clone https://github.com/your-org/agentforge.git
-cd agentforge
+git clone https://github.com/hetaoBackend/agentforge.git
+cd agentforge/taskboard-electron
-# Install all dependencies
-make install-deps
-
-# Build and package a DMG
-make package-dmg
-# Output: taskboard-electron/out/make/AgentForge-1.0.0-arm64.dmg
+bun install --ignore-scripts
+bun run start
```
-### Option 3: Development Mode
+The Electron dev command builds the renderer, starts the Bun backend, and reloads the app while you work.
-```bash
-git clone https://github.com/your-org/agentforge.git
-cd agentforge
+### Build A DMG
-make install-deps # bun install in backend/ and taskboard-electron/
-
-# Start Electron + backend (Bun builds, watches, and spawns the backend)
-cd taskboard-electron && bun run start
+```bash
+cd taskboard-electron
+bun run make
```
----
-
-## Troubleshooting
+The packaged app bundles the compiled Bun backend at `taskboard-electron/out/make/AgentForge-1.0.0-arm64.dmg`.
-### `bun install` hangs or freezes
+## What You Can Do
-This is the most common setup issue. The Electron binary (~100 MB) is downloaded from GitHub and may stall on slow connections or in China.
+| Area | What it gives you |
+| --- | --- |
+| **Tasks** | Kanban queue for pending, scheduled, blocked, running, completed, failed, and cancelled work. |
+| **Scheduling** | Immediate, delayed, `scheduled_at`, and cron schedules with max-run limits. |
+| **Live output** | Structured stream output from Claude Code or Codex CLI, persisted per run. |
+| **Heartbeats** | Recurring checks that can decide whether to trigger, resume, or notify. |
+| **Skill Library** | Pattern detection across completed runs, editable `SKILL.md` drafts, and native skill installation. |
+| **Chat channels** | Telegram, Slack, Feishu/Lark, and WeChat adapters for creating or tracking tasks from chat. |
+| **DAG pipelines** | Task dependencies, failure propagation, and upstream result injection for multi-agent workflows. |
-**Quick fix — use mirrors:**
+## Requirements
-```bash
-export ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/
-cd taskboard-electron && bun install --registry https://registry.npmmirror.com
-```
+- macOS 12+
+- [Bun](https://bun.sh) 1.3+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) or [OpenAI Codex CLI](https://github.com/openai/codex) on `PATH`
-**Full guide:** [docs/installation-troubleshooting.md](docs/installation-troubleshooting.md) covers:
-- How to diagnose whether the hang is network or native compilation
-- Mirror setup for China and slow connections
-- Installing build tools (macOS / Linux / Windows)
-- Node.js version requirements
-- Full clean-install procedure
+## Skill Library
----
+The Skill Library turns repeated work into reusable agent skills.
-## Quick Start
+1. **Detect** recurring recipes and pitfalls across completed task runs.
+2. **Distill** useful patterns into standard `SKILL.md` drafts.
+3. **Approve** the draft before anything is installed.
+4. **Deliver** approved skills to `~/.agentforge/skills`, symlinked into `~/.claude/skills` and `~/.agents/skills`.
-Once the app is running, the backend listens on `http://127.0.0.1:9712`.
+The automatic sweep is off by default because it spends tokens. Enable it in Settings, or run a manual scan from the Skills tab.
-**Create a task via the UI:** Open AgentForge, click **New Task**, fill in the title, prompt, and working directory, choose a schedule type, and click **Create**.
+## Architecture
-**Create a task via curl:**
+```text
+┌─────────────────────┐ HTTP/JSON ┌─────────────────────┐
+│ Electron + React UI │ <--------------------> │ Bun TypeScript API │
+│ Task board renderer │ 127.0.0.1:9712 │ Scheduler + runner │
+└─────────────────────┘ └──────────┬──────────┘
+ │
+ ┌─────────────────────┼─────────────────────┐
+ │ │ │
+ SQLite TaskScheduler AgentExecutor
+ ~/.agentforge cron + delayed claude / codex
+```
-```bash
-# Run immediately (uses default agent — claude)
-curl -X POST http://localhost:9712/api/tasks \
- -H "Content-Type: application/json" \
- -d '{
- "title": "Code review",
- "prompt": "Review the code changes in this directory",
- "working_dir": "~/projects/myapp",
- "schedule_type": "immediate"
- }'
+- `taskboard-electron/src/main.ts` starts and stops the backend with the desktop app.
+- `taskboard-electron/src/renderer/App.tsx` renders the task board, heartbeats, settings, and skills.
+- `backend/taskboard.ts` serves the REST API through `Bun.serve`.
+- `backend/src/db.ts` stores tasks, runs, output events, settings, heartbeats, and skills in SQLite.
+- `backend/src/executor.ts` runs Claude Code or Codex CLI and persists streaming output.
+- `backend/src/scheduler.ts` polls for due tasks and handles schedules, heartbeats, and skill sweeps.
-# Run after a delay (seconds)
-curl -X POST http://localhost:9712/api/tasks \
- -H "Content-Type: application/json" \
- -d '{
- "title": "Delayed review",
- "prompt": "Review recent commits",
- "working_dir": "~/projects/myapp",
- "schedule_type": "delayed",
- "delay_seconds": 300
- }'
+## API Quick Example
-# Recurring cron schedule (daily at 9 AM)
-curl -X POST http://localhost:9712/api/tasks \
- -H "Content-Type: application/json" \
- -d '{
- "title": "Daily digest",
- "prompt": "Summarize TODO comments across the codebase",
- "working_dir": "~/projects/myapp",
- "schedule_type": "cron",
- "cron_expr": "0 9 * * *",
- "max_runs": 30
- }'
+All API routes are served at `http://127.0.0.1:9712/api`.
-# Use Codex CLI instead of Claude Code
-curl -X POST http://localhost:9712/api/tasks \
+```bash
+curl -X POST http://127.0.0.1:9712/api/tasks \
-H "Content-Type: application/json" \
-d '{
- "title": "Refactor auth module",
- "prompt": "Refactor the authentication module for clarity",
+ "title": "Review auth changes",
+ "prompt": "Review the latest auth module diff for regressions and missing tests.",
"working_dir": "~/projects/myapp",
"schedule_type": "immediate",
"agent": "codex"
}'
```
-To set Codex as the default agent for all tasks:
+Common task endpoints:
-```bash
-curl -X PUT http://localhost:9712/api/settings \
- -H "Content-Type: application/json" \
- -d '{"default_agent": "codex"}'
-```
-
----
+| Method | Endpoint | Description |
+| --- | --- | --- |
+| `GET` | `/api/tasks` | List tasks |
+| `POST` | `/api/tasks` | Create a task |
+| `GET` | `/api/tasks/:id` | Read one task |
+| `POST` | `/api/tasks/:id/cancel` | Cancel a task |
+| `POST` | `/api/tasks/:id/retry` | Retry a failed task |
+| `GET` | `/api/tasks/:id/events` | Read structured output events |
+| `GET` | `/api/health` | Backend health check |
## Chat Channels
-Control AgentForge from your favorite messaging app. Channels auto-start when the corresponding environment variables are detected.
+Channels are optional. They let teammates create tasks or receive updates from the tools where they already talk.
-| Channel | Transport | Difficulty |
-|---------|-----------|------------|
-| Telegram | Bot API (polling) | Easy |
-| Slack | Socket Mode | Moderate |
-| Feishu / Lark | WebSocket long-connection | Moderate |
-| WeChat | Node bridge (experimental) | Moderate |
+| Channel | Transport | Notes |
+| --- | --- | --- |
+| Telegram | Bot API polling | Simple bot token setup. |
+| Slack | Socket Mode | Uses bot and app-level tokens. |
+| Feishu / Lark | WebSocket long connection | No public IP required. |
+| WeChat | Local bridge | Experimental text-only bridge. |
-
-Telegram setup
+Channel adapters live in `backend/src/channels/` and can be configured from the app settings page or REST endpoints.
-### 1. Create a Bot
+## Multi-Agent Pipelines
-1. Chat with [@BotFather](https://t.me/BotFather) on Telegram.
-2. Send `/newbot` and follow the prompts.
-3. Copy the **HTTP API token**.
+AgentForge ships with `skills/agentforge/`, a Claude Code skill that lets one task create and manage other AgentForge tasks.
-### 2. Configure
+That enables fan-out research, fan-in summaries, dependency gates, upstream result injection, and scheduled sub-workflows.
-```bash
-export TELEGRAM_BOT_TOKEN="123456789:ABCdefGHIjklMNOpqrSTUvwxYZ"
-export TELEGRAM_ALLOWED_USERS="123456789" # optional — restrict access by user ID
+```text
+User
+ |
+ v
+Task A --creates--> Task B
+ | Task C
+ | |
+ `------depends------v
+ Task D
```
-### 3. Commands
-
-| Command | Description |
-|---------|-------------|
-| `/newtask \| ` | Create a task |
-| `/list` | List all tasks |
-| `/status ` | Task details |
-| `/cancel ` | Cancel a task |
-| `/help` | Show help |
-
-
-
-
-Slack setup
-
-### 1. Create a Slack App
-
-Go to [api.slack.com/apps](https://api.slack.com/apps) → **Create New App → From scratch**.
-
-### 2. Bot Permissions
-
-Under **OAuth & Permissions → Bot Token Scopes**, add:
-`app_mentions:read`, `chat:write`, `im:history`, `im:read`, `im:write`, `reactions:write`
-
-### 3. Enable Socket Mode
-
-**Socket Mode** → toggle on → generate an **App-Level Token** (`xapp-…`) with `connections:write`.
-
-### 4. Subscribe to Events
-
-**Event Subscriptions → Subscribe to bot events**: `app_mention`, `message.im`
-
-### 5. Configure
+Install the bundled skill:
```bash
-export SLACK_BOT_TOKEN="xoxb-..."
-export SLACK_APP_TOKEN="xapp-..."
-export SLACK_ALLOWED_USERS="U012AB3CD" # optional
+ln -s /path/to/agentforge/skills/agentforge ~/.claude/skills/agentforge
```
-### 6. Commands
-
-Send as a DM or @mention:
+## Development
-| Command | Description |
-|---------|-------------|
-| `newtask \| ` | Create a task |
-| `list` | List all tasks |
-| `status ` | Task details |
-| `cancel ` | Cancel a task |
-
-
-
-
-Feishu / Lark setup
-
-Feishu uses the settings API (no environment variables needed). It connects via WebSocket — no public IP required.
-
-### 1. Create a Feishu App
-
-- [Feishu Open Platform](https://open.feishu.cn/app) → new app → enable **Bot**
-- Permissions: `im:message`, `im:resource`
-- Events: `im.message.receive_v1` with **Long Connection** mode
-- Copy **App ID** and **App Secret**
-
-### 2. Configure via API
+Backend:
```bash
-curl -X POST http://127.0.0.1:9712/api/feishu/settings \
- -H "Content-Type: application/json" \
- -d '{
- "feishu_app_id": "cli_xxxx",
- "feishu_app_secret": "your_app_secret",
- "feishu_default_working_dir": "~/projects",
- "feishu_enabled": "true"
- }'
+cd backend
+bun taskboard.ts
```
-Or configure from the desktop app's settings page.
-
-
-
-
-WeChat setup (experimental)
-
-WeChat uses a Bun/TypeScript sidecar bridge — no environment variables needed. Configure and enable it via the API or the desktop app's settings page.
-
-### 1. Enable via API
+Frontend and Electron app:
```bash
-curl -X POST http://127.0.0.1:9712/api/channels/settings \
- -H "Content-Type: application/json" \
- -d '{
- "weixin_enabled": "true",
- "weixin_default_working_dir": "~/projects",
- "weixin_base_url": "https://ilinkai.weixin.qq.com",
- "weixin_account_id": ""
- }'
+cd taskboard-electron
+bun run start
```
-### 2. Scan the QR code
-
-On first launch the bridge will request a QR code login. Scan it with your WeChat mobile app to authenticate. The session is saved for subsequent restarts.
-
-### Notes
-
-- Text-only MVP — rich media is not supported.
-- The bridge uses the `getupdates` / `sendmessage` HTTP protocol.
-- Single-account per AgentForge instance.
-
-
-
-Channel adapters live in [`backend/src/channels/`](backend/src/channels/). Configure them from the desktop app settings page or the REST endpoints shown above.
-
----
-
-## Multi-Agent Pipelines (DAG)
-
-AgentForge ships with a **Claude Code skill** (`skills/agentforge/`) that lets any agent running inside Claude Code create and manage other AgentForge tasks — enabling recursive, multi-agent workflows.
-
-```
- User
- |
- v
- [ Task A ] ──creates──> [ Task B ] [ Task C ]
- |
- creates
- v
- [ Task D ] (depends on B)
-```
-
-### Install the skill
+Quality gates:
```bash
-# Symlink into your Claude Code skills directory
-ln -s /path/to/agentforge/skills/agentforge ~/.claude/skills/agentforge
-```
-
-### What the skill enables
-
-- **Fan-out / fan-in** — Spawn N sub-tasks in parallel, poll until complete, synthesize results
-- **DAG dependencies** — `--depends-on ` makes downstream tasks wait for upstream to finish; failures cascade-cancel the rest
-- **Result injection** — `--inject-result` prepends upstream output into the downstream prompt automatically
-- **Scheduled sub-workflows** — Combine cron, delayed, and immediate schedules within a pipeline
+# Backend CI gate
+make check
-### Example — parallel research pipeline
-
-```
-Research the top 3 competitors of Acme Corp.
-For each competitor, create a separate AgentForge task that:
- 1. Gathers recent news and financials
- 2. Writes a one-page summary
-Then create a final task (depends-on the above 3) that
-synthesizes everything into a comparative report.
+# Frontend CI gate
+cd taskboard-electron
+bun run typecheck
+bun run lint
+bun run format:check
+bun run test
+bun run build:check
```
-AgentForge handles scheduling, dependency tracking, and result passing automatically.
-
----
-
-## API Reference
+## Troubleshooting
-All endpoints are served at `http://127.0.0.1:9712/api`.
-
-| Method | Endpoint | Description |
-|--------|----------|-------------|
-| GET | `/api/tasks` | List all tasks |
-| GET | `/api/tasks/:id` | Get a single task |
-| POST | `/api/tasks` | Create a task |
-| POST | `/api/tasks/:id/cancel` | Cancel a task |
-| POST | `/api/tasks/:id/retry` | Retry a failed task |
-| DELETE | `/api/tasks/:id` | Delete a task |
-| GET | `/api/tasks/:id/runs` | Get run history |
-| GET | `/api/tasks/:id/output` | Get accumulated output |
-| GET | `/api/tasks/:id/events` | Get structured output events |
-| GET | `/api/health` | Health check |
-
----
-
-## Background Service
-
-To keep the backend running persistently without the desktop app:
-
-```xml
-
-
-
-
-
- Label
- com.agentforge.taskboard
- ProgramArguments
-
- /usr/local/bin/bun
- /path/to/agentforge/backend/taskboard.ts
-
- WorkingDirectory
- /path/to/agentforge
- RunAtLoad
-
- KeepAlive
-
- StandardOutPath
- /tmp/agentforge.log
- StandardErrorPath
- /tmp/agentforge.err
-
-
-```
+If `bun install` stalls while downloading Electron, use a mirror:
```bash
-launchctl load ~/Library/LaunchAgents/com.agentforge.taskboard.plist
-```
-
----
-
-## Architecture
-
-```
-┌──────────────────┐ HTTP/JSON ┌──────────────────┐
-│ React Frontend │ <────────────────> │ Bun/TS Backend │
-│ (Kanban UI) │ localhost:9712 │ (Scheduler+API) │
-└──────────────────┘ └───────┬──────────┘
- |
- ┌───────────────┼───────────────┐
- v v v
- [ SQLite DB ] [ Scheduler ] [ Claude CLI ]
+export ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/
+cd taskboard-electron
+bun install --registry https://registry.npmmirror.com --ignore-scripts
```
-- **Bun/TypeScript backend** (`backend/`) — `Bun.serve` HTTP server. Manages tasks in SQLite via `bun:sqlite` (`~/.agentforge/tasks.db`), runs `claude` or `codex` CLI via `AgentExecutor`, and schedules work with `TaskScheduler` (polls every 2 s, supports cron via `cron-parser`).
-- **Electron shell** (`taskboard-electron/`) — spawns the backend on start, kills it on quit. Renderer/main/preload are bundled with `Bun.build` (`scripts/build.ts`); in dev `bun run start` watches and reloads.
-- **React frontend** (`App.tsx`) — single-component kanban board that polls the REST API and renders colorized streaming output.
-
----
+More setup notes live in [docs/installation-troubleshooting.md](docs/installation-troubleshooting.md).
## Contributing
-Contributions are welcome! Here's how to get started:
-
1. Fork the repository and create a feature branch.
-2. Start the app in development mode (see [Option 3](#option-3-development-mode) above).
-3. Make your changes and run the relevant Bun quality gate (`make check` for backend changes; the frontend gate from `taskboard-electron/` for renderer/Electron changes).
-4. Open a pull request with a clear description of the change.
+2. Run the app in development mode with `cd taskboard-electron && bun run start`.
+3. Keep changes scoped and run the relevant quality gate before opening a PR.
-**Key files:**
-- `backend/` — entire TypeScript backend (DB, scheduler, executor, HTTP API, channels)
-- `taskboard-electron/src/main.ts` — Electron main process
-- `taskboard-electron/src/renderer/App.tsx` — React frontend
-- `backend/src/channels/` — pluggable chat channel adapters (Telegram, Slack, Feishu, WeChat)
-- `skills/agentforge/` — Claude Code skill for agent-to-agent delegation
+Key files:
----
+- `backend/` - Bun/TypeScript backend, scheduler, executor, API, and channels.
+- `taskboard-electron/src/main.ts` - Electron main process.
+- `taskboard-electron/src/renderer/App.tsx` - React renderer.
+- `skills/agentforge/` - bundled skill for agent-to-agent delegation.
## License
-MIT — see [LICENSE](LICENSE) for details.
+MIT - see [LICENSE](LICENSE).
diff --git a/README.zh.md b/README.zh.md
index f9e1b06..8f1b749 100644
--- a/README.zh.md
+++ b/README.zh.md
@@ -1,426 +1,224 @@
# AgentForge
-> 在 Mac 上编排 AI 编程智能体 —— 通过看板界面调度、监控和串联 Claude Code 任务。
+**一个本地优先的 macOS 智能体工作台,用看板方式调度、观察和复用 Claude Code / OpenAI Codex CLI 任务。**
[](LICENSE)
-[](https://github.com/releases)
-[](https://bun.sh) [](https://www.typescriptlang.org)
-[](https://docs.anthropic.com/en/docs/claude-code)
+[](../../releases)
+[](https://bun.sh)
+[](https://www.typescriptlang.org)
-**官网**: https://agentforge-landing-weld.vercel.app/
+AgentForge 把 AI 编程智能体变成可见、可排队、可调度的本地工作流。你可以创建任务、查看实时输出、设置周期检查、从聊天工具触发任务,并把重复工作沉淀成可复用技能。
-
+**官网:** https://agentforge-landing-weld.vercel.app/
----
+
-## 目录
+## 为什么用 AgentForge
-- [功能特性](#功能特性)
-- [技能库(Skill Library)](#技能库skill-library)
-- [环境要求](#环境要求)
-- [安装](#安装)
-- [常见问题](#常见问题)
-- [快速开始](#快速开始)
-- [消息频道](#消息频道)
-- [多智能体流水线(DAG)](#多智能体流水线dag)
-- [API 参考](#api-参考)
-- [后台服务](#后台服务)
-- [架构说明](#架构说明)
-- [参与贡献](#参与贡献)
-- [许可证](#许可证)
+- **不用盯着终端等结果。** 把任务放进队列,从 Queue / Running / Done 看板里查看状态。
+- **每个任务选择合适智能体。** 任务级支持 Claude Code 或 Codex CLI,也可以设置默认智能体。
+- **把重复工作产品化。** 支持立即、延迟、定时和 cron 调度,成功模式还可以进入 Skill Library。
+- **执行留在本机。** 后端只监听 `127.0.0.1`,状态存进 SQLite,智能体 CLI 在你的 Mac 上运行。
----
-
-## 功能特性
-
-- **🧬 自复利技能库(Skill Library)** —— AgentForge 自动发现你反复跑的任务模式,借助 Anthropic [skill-creator](https://github.com/anthropics/skills/tree/main/skills/skill-creator) 蒸馏成可复用的 Claude Code Skill。审核、批准后自动 symlink 进 Claude Code 与 Codex —— 用得越多,agent 越懂你的活。[了解更多 →](#技能库skill-library)
-- **智能体生成智能体** —— 任何运行中的任务都可通过内置的 Claude Code Skill 创建子任务、构建 DAG 流水线并汇总结果
-- **看板任务视图** —— 可视化的「待执行 / 运行中 / 已完成」三列布局,支持实时输出流
-- **DAG 流水线** —— 定义任务依赖关系,支持自动级联执行和失败传播
-- **灵活调度** —— 即刻执行、延迟执行、指定时间一次性执行、cron 周期任务
-- **消息频道控制** —— 通过 Telegram、Slack 或飞书/Lark 创建任务并接收完成通知
-- **持久化存储** —— SQLite 存储任务历史、运行记录和流式输出
-- **原生 macOS 应用** —— Electron 封装,一键 DMG 安装
-
----
-
-## 技能库(Skill Library)
-
-**把你反复做的活,自动沉淀成 agent 可复用的技能。** 用得越多,AgentForge 越懂你的工作流。
-
-1. **检测** —— 后台定时扫描(或手动点「扫一遍」)分析你已完成的任务,把跨任务复发的模式记进账本:既包括*成功配方*(你反复跑的工作流),也包括*避坑*(你诊断并修好的失败)。按 run 幂等计数,重复扫描不会灌水。
-2. **蒸馏** —— 对值得固化的模式,AgentForge 用 Anthropic 的 **[skill-creator](https://github.com/anthropics/skills/tree/main/skills/skill-creator)** 技能起草规范的 `SKILL.md` —— 而且会**先判断到底值不值得**做成 skill,免得噪声泛滥。
-3. **审批** —— 审阅草稿:价值判定、贡献的任务、以及完全可编辑的 `SKILL.md`,批准或驳回,决定权在你。
-4. **投递** —— 批准后写一份 canonical 文件,并 symlink 进 **Claude Code**(`~/.claude/skills`)和 **Codex**(`~/.agents/skills`)两个原生目录,两个 agent 都按渐进式披露原生加载 —— 零 prompt 注入。
-5. **管理** —— 在 **Skills** 标签里逐个启用/停用(增删 symlink,保留文件)、查看 `SKILL.md`、或删除。
-
-> 自动每日扫描**默认关闭**(会消耗 token)。在 **设置 → Skill Library** 里打开、选 agent 和节奏,或随时点手动「扫一遍」—— 手动按钮不受阈值限制,永远可用。
-
-蒸馏出的都是标准 Claude Code `SKILL.md` 文件(canonical 存于 `~/.agentforge/skills`,symlink 到各 agent 原生目录)—— 可移植、可检视、零锁定。
-
----
-
-## 环境要求
-
-- macOS 12.0+(Apple Silicon 或 Intel)
-- [Bun](https://bun.sh) 1.3+
-- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code)(已安装并在 `PATH` 中)
-
----
-
-## 安装
+## 快速开始
-### 方式一:桌面应用(推荐)
+### 安装桌面 App
-1. 从 [Releases](../../releases) 页面下载最新的 `AgentForge-*.dmg`。
-2. 打开 DMG,将 **AgentForge** 拖入 `/Applications`。
-3. 从启动台或应用程序文件夹打开。
+1. 从 [Releases](../../releases) 下载最新 `AgentForge-*.dmg`。
+2. 把 **AgentForge** 拖进 `/Applications`。
+3. 启动 App,选择工作目录,创建第一个任务。
-### 方式二:从源码构建
+### 从源码运行
```bash
-git clone https://github.com/your-org/agentforge.git
-cd agentforge
-
-# 安装全部依赖
-make install-deps
+git clone https://github.com/hetaoBackend/agentforge.git
+cd agentforge/taskboard-electron
-# 构建并打包 DMG
-make package-dmg
-# 输出路径:taskboard-electron/out/make/AgentForge-1.0.0-arm64.dmg
+bun install --ignore-scripts
+bun run start
```
-### 方式三:开发模式
+开发命令会构建 Electron/React 前端、启动 Bun 后端,并在改动后自动刷新。
-```bash
-git clone https://github.com/your-org/agentforge.git
-cd agentforge
-
-make install-deps # bun install in backend/ and taskboard-electron/
+### 构建 DMG
-# 启动 Electron + 后端(Bun 负责构建、监听并自动拉起后端)
-cd taskboard-electron && bun run start
+```bash
+cd taskboard-electron
+bun run make
```
----
+产物位于 `taskboard-electron/out/make/AgentForge-1.0.0-arm64.dmg`。
-## 常见问题
+## 核心能力
-### `bun install` 卡住不动
+| 模块 | 作用 |
+| --- | --- |
+| **Tasks** | Pending、scheduled、blocked、running、completed、failed、cancelled 任务看板。 |
+| **Scheduling** | 支持 immediate、delayed、`scheduled_at`、cron 和最大运行次数。 |
+| **Live output** | 持久化 Claude Code / Codex CLI 的结构化流式输出。 |
+| **Heartbeats** | 周期检查,可以决定 trigger、resume 或 notify。 |
+| **Skill Library** | 从完成任务中发现模式,生成可编辑 `SKILL.md`,再安装到智能体技能目录。 |
+| **Chat channels** | Telegram、Slack、飞书/Lark、微信渠道可创建或跟踪任务。 |
+| **DAG pipelines** | 支持任务依赖、失败传播和上游结果注入。 |
-这是最常见的安装问题。Electron 二进制包约 100MB,从 GitHub 下载,在国内网络环境下极易卡住。
+## 环境要求
-**快速解决——使用国内镜像:**
+- macOS 12+
+- [Bun](https://bun.sh) 1.3+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) 或 [OpenAI Codex CLI](https://github.com/openai/codex) 在 `PATH` 中
-```bash
-export ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/
-cd taskboard-electron && bun install --registry https://registry.npmmirror.com
-```
+## Skill Library
-**完整排查指南:** [docs/installation-troubleshooting.md](docs/installation-troubleshooting.md),涵盖:
-- 如何判断是网络卡住还是编译卡住
-- 国内镜像及永久配置方法
-- macOS / Linux / Windows 编译工具安装
-- Node.js 版本要求
-- 完整清理重装流程
+Skill Library 会把你反复做的工作沉淀成智能体可复用技能。
----
+1. **Detect**: 从已完成任务中发现重复 recipe 和常见 pitfall。
+2. **Distill**: 把值得复用的模式蒸馏成标准 `SKILL.md` 草稿。
+3. **Approve**: 你先审核和编辑草稿,再决定是否安装。
+4. **Deliver**: 批准后的技能写入 `~/.agentforge/skills`,并 symlink 到 `~/.claude/skills` 与 `~/.agents/skills`。
-## 快速开始
+自动 sweep 默认关闭,因为它会消耗 token。你可以在 Settings 里开启,也可以在 Skills tab 手动扫描。
-应用启动后,后端监听在 `http://127.0.0.1:9712`。
+## 架构
-**通过 UI 创建任务:** 打开 AgentForge,点击 **New Task**,填写标题、提示词和工作目录,选择调度类型后点击 **Create**。
+```text
+┌─────────────────────┐ HTTP/JSON ┌─────────────────────┐
+│ Electron + React UI │ <--------------------> │ Bun TypeScript API │
+│ Task board renderer │ 127.0.0.1:9712 │ Scheduler + runner │
+└─────────────────────┘ └──────────┬──────────┘
+ │
+ ┌─────────────────────┼─────────────────────┐
+ │ │ │
+ SQLite TaskScheduler AgentExecutor
+ ~/.agentforge cron + delayed claude / codex
+```
-**通过命令行创建任务:**
+- `taskboard-electron/src/main.ts` 随桌面 App 启停后端。
+- `taskboard-electron/src/renderer/App.tsx` 渲染任务看板、心跳、设置和技能库。
+- `backend/taskboard.ts` 通过 `Bun.serve` 暴露 REST API。
+- `backend/src/db.ts` 用 SQLite 存储任务、运行记录、输出事件、设置、心跳和技能。
+- `backend/src/executor.ts` 运行 Claude Code 或 Codex CLI,并持久化流式输出。
+- `backend/src/scheduler.ts` 轮询 due tasks,并处理调度、心跳和技能扫描。
-```bash
-# 立即执行
-curl -X POST http://localhost:9712/api/tasks \
- -H "Content-Type: application/json" \
- -d '{
- "title": "代码审查",
- "prompt": "审查当前目录的代码变更",
- "working_dir": "~/projects/myapp",
- "schedule_type": "immediate"
- }'
+## API 示例
-# 延迟执行(300 秒后)
-curl -X POST http://localhost:9712/api/tasks \
- -H "Content-Type: application/json" \
- -d '{
- "title": "延迟审查",
- "prompt": "审查最近的提交",
- "working_dir": "~/projects/myapp",
- "schedule_type": "delayed",
- "delay_seconds": 300
- }'
+所有 API 都在 `http://127.0.0.1:9712/api` 下。
-# cron 周期任务(每天早上 9 点)
-curl -X POST http://localhost:9712/api/tasks \
+```bash
+curl -X POST http://127.0.0.1:9712/api/tasks \
-H "Content-Type: application/json" \
-d '{
- "title": "每日摘要",
- "prompt": "汇总代码库中的所有 TODO 注释",
+ "title": "Review auth changes",
+ "prompt": "Review the latest auth module diff for regressions and missing tests.",
"working_dir": "~/projects/myapp",
- "schedule_type": "cron",
- "cron_expr": "0 9 * * *",
- "max_runs": 30
+ "schedule_type": "immediate",
+ "agent": "codex"
}'
```
----
-
-## 消息频道
+常用任务接口:
-通过消息应用控制 AgentForge。检测到对应环境变量后,频道会自动启动。
+| Method | Endpoint | Description |
+| --- | --- | --- |
+| `GET` | `/api/tasks` | 列出任务 |
+| `POST` | `/api/tasks` | 创建任务 |
+| `GET` | `/api/tasks/:id` | 读取单个任务 |
+| `POST` | `/api/tasks/:id/cancel` | 取消任务 |
+| `POST` | `/api/tasks/:id/retry` | 重试失败任务 |
+| `GET` | `/api/tasks/:id/events` | 读取结构化输出事件 |
+| `GET` | `/api/health` | 后端健康检查 |
-| 频道 | 传输方式 | 配置难度 |
-|------|----------|----------|
-| Telegram | Bot API(轮询) | 简单 |
-| Slack | Socket Mode | 中等 |
-| 飞书 / Lark | WebSocket 长连接 | 中等 |
+## 消息渠道
-
-Telegram 配置
+消息渠道是可选能力,用来从常用聊天工具创建任务或接收状态更新。
-### 1. 创建机器人
-
-1. 在 Telegram 中与 [@BotFather](https://t.me/BotFather) 对话。
-2. 发送 `/newbot` 并按提示操作。
-3. 复制 **HTTP API Token**。
-
-### 2. 配置环境变量
-
-```bash
-export TELEGRAM_BOT_TOKEN="123456789:ABCdefGHIjklMNOpqrSTUvwxYZ"
-export TELEGRAM_ALLOWED_USERS="123456789" # 可选——限制允许访问的用户 ID
-```
+| 渠道 | 传输方式 | 说明 |
+| --- | --- | --- |
+| Telegram | Bot API polling | 配置 bot token 即可使用。 |
+| Slack | Socket Mode | 使用 bot token 和 app-level token。 |
+| 飞书 / Lark | WebSocket long connection | 不需要公网 IP。 |
+| 微信 | Local bridge | 实验性文本渠道。 |
-### 3. 可用命令
+渠道适配器位于 `backend/src/channels/`,可以在 App 设置页或 REST API 中配置。
-| 命令 | 说明 |
-|------|------|
-| `/newtask <标题> \| <提示词>` | 创建任务 |
-| `/list` | 列出所有任务 |
-| `/status ` | 查看任务详情 |
-| `/cancel ` | 取消任务 |
-| `/help` | 显示帮助 |
+## 多智能体流水线
-
+AgentForge 自带 `skills/agentforge/`,让 Claude Code 中运行的任务可以创建和管理其他 AgentForge 任务。
-
-Slack 配置
+这可以用于并行研究、结果汇总、依赖卡点、上游结果注入和周期性子工作流。
-### 1. 创建 Slack App
-
-前往 [api.slack.com/apps](https://api.slack.com/apps) → **Create New App → From scratch**。
-
-### 2. Bot 权限
-
-在 **OAuth & Permissions → Bot Token Scopes** 中添加:
-`app_mentions:read`、`chat:write`、`im:history`、`im:read`、`im:write`、`reactions:write`
-
-### 3. 启用 Socket Mode
-
-**Socket Mode** → 开启 → 生成 **App-Level Token**(`xapp-…`),scope 选 `connections:write`。
-
-### 4. 订阅事件
-
-**Event Subscriptions → Subscribe to bot events**:`app_mention`、`message.im`
-
-### 5. 配置环境变量
-
-```bash
-export SLACK_BOT_TOKEN="xoxb-..."
-export SLACK_APP_TOKEN="xapp-..."
-export SLACK_ALLOWED_USERS="U012AB3CD" # 可选
+```text
+User
+ |
+ v
+Task A --creates--> Task B
+ | Task C
+ | |
+ `------depends------v
+ Task D
```
-### 6. 可用命令
-
-以私信或 @mention 方式发送:
-
-| 命令 | 说明 |
-|------|------|
-| `newtask <标题> \| <提示词>` | 创建任务 |
-| `list` | 列出所有任务 |
-| `status ` | 查看任务详情 |
-| `cancel ` | 取消任务 |
-
-
-
-
-飞书 / Lark 配置
-
-飞书通过设置 API 配置(无需环境变量),通过 WebSocket 长连接通信,无需公网 IP。
-
-### 1. 创建飞书应用
-
-- 前往 [飞书开放平台](https://open.feishu.cn/app) → 新建应用 → 开启**机器人**能力
-- 权限:`im:message`、`im:resource`
-- 事件:`im.message.receive_v1`,选择**长连接**模式
-- 复制 **App ID** 和 **App Secret**
-
-### 2. 通过 API 配置
+安装内置技能:
```bash
-curl -X POST http://127.0.0.1:9712/api/feishu/settings \
- -H "Content-Type: application/json" \
- -d '{
- "feishu_app_id": "cli_xxxx",
- "feishu_app_secret": "your_app_secret",
- "feishu_default_working_dir": "~/projects",
- "feishu_enabled": "true"
- }'
+ln -s /path/to/agentforge/skills/agentforge ~/.claude/skills/agentforge
```
-也可以在桌面应用的设置页面中配置。
+## 开发
-
-
-频道适配器位于 [`backend/src/channels/`](backend/src/channels/),可在桌面应用设置页或上面的 REST 接口中配置。
-
----
-
-## 多智能体流水线(DAG)
-
-AgentForge 内置了一个 **Claude Code Skill**(`skills/agentforge/`),让任何在 Claude Code 中运行的智能体都能创建和管理其他 AgentForge 任务,从而实现递归的多智能体工作流。
-
-```
- 用户
- |
- v
- [ 任务 A ] ──创建──> [ 任务 B ] [ 任务 C ]
- |
- 创建
- v
- [ 任务 D ] (依赖 B)
-```
-
-### 安装 Skill
+后端:
```bash
-# 将 skill 目录符号链接到 Claude Code skills 目录
-ln -s /path/to/agentforge/skills/agentforge ~/.claude/skills/agentforge
+cd backend
+bun taskboard.ts
```
-### Skill 的能力
-
-- **扇出 / 扇入** —— 并行创建 N 个子任务,轮询等待全部完成后汇总结果
-- **DAG 依赖** —— `--depends-on ` 使下游任务等待上游完成;上游失败会级联取消下游
-- **结果注入** —— `--inject-result` 自动将上游输出追加到下游任务的提示词中
-- **调度子工作流** —— 在流水线中混合使用 cron、延迟和即刻调度
-
-### 示例——并行研究流水线
+前端和 Electron App:
-```
-研究 Acme Corp 的前 3 名竞争对手。
-针对每个竞争对手,分别创建一个 AgentForge 任务:
- 1. 收集近期新闻和财务数据
- 2. 撰写一页摘要报告
-然后创建一个汇总任务(依赖上面 3 个任务),
-将所有内容整合成一份对比分析报告。
+```bash
+cd taskboard-electron
+bun run start
```
-AgentForge 自动处理调度、依赖追踪和结果传递。
-
----
-
-## API 参考
-
-所有接口均在 `http://127.0.0.1:9712/api` 下提供。
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/api/tasks` | 获取所有任务 |
-| GET | `/api/tasks/:id` | 获取单个任务 |
-| POST | `/api/tasks` | 创建任务 |
-| POST | `/api/tasks/:id/cancel` | 取消任务 |
-| POST | `/api/tasks/:id/retry` | 重试失败任务 |
-| DELETE | `/api/tasks/:id` | 删除任务 |
-| GET | `/api/tasks/:id/runs` | 获取运行历史 |
-| GET | `/api/tasks/:id/output` | 获取累计输出 |
-| GET | `/api/tasks/:id/events` | 获取结构化输出事件 |
-| GET | `/api/health` | 健康检查 |
-
----
-
-## 后台服务
-
-如需在不打开桌面应用的情况下持续运行后端,可用 launchd 托管:
-
-```xml
-
-
-
-
-
- Label
- com.agentforge.taskboard
- ProgramArguments
-
- /usr/local/bin/bun
- /path/to/agentforge/backend/taskboard.ts
-
- WorkingDirectory
- /path/to/agentforge
- RunAtLoad
-
- KeepAlive
-
- StandardOutPath
- /tmp/agentforge.log
- StandardErrorPath
- /tmp/agentforge.err
-
-
-```
+质量门禁:
```bash
-launchctl load ~/Library/LaunchAgents/com.agentforge.taskboard.plist
+# Backend CI gate
+make check
+
+# Frontend CI gate
+cd taskboard-electron
+bun run typecheck
+bun run lint
+bun run format:check
+bun run test
+bun run build:check
```
----
+## 常见问题
-## 架构说明
+如果 `bun install` 下载 Electron 时卡住,可以使用镜像:
-```
-┌──────────────────┐ HTTP/JSON ┌──────────────────┐
-│ React 前端 │ <────────────────> │ Bun/TS 后端 │
-│ (看板 UI) │ localhost:9712 │ (调度器+API) │
-└──────────────────┘ └───────┬──────────┘
- |
- ┌───────────────┼───────────────┐
- v v v
- [ SQLite DB ] [ 调度器 ] [ Claude CLI ]
+```bash
+export ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/
+cd taskboard-electron
+bun install --registry https://registry.npmmirror.com --ignore-scripts
```
-- **Bun/TypeScript 后端**(`backend/`)—— `Bun.serve` HTTP 服务。通过 `bun:sqlite` 在 SQLite(`~/.agentforge/tasks.db`)中管理任务,通过 `AgentExecutor` 运行 `claude` / `codex` CLI,通过 `TaskScheduler` 调度任务(每 2 秒轮询,支持通过 `cron-parser` 解析 cron 表达式)。
-- **Electron 外壳**(`taskboard-electron/`)—— 启动时创建后端进程,退出时终止它。主进程/preload/渲染器均由 `Bun.build` 打包(`scripts/build.ts`);开发模式 `bun run start` 自动监听并热重载。
-- **React 前端**(`App.tsx`)—— 单组件看板,轮询 REST API 并渲染带颜色的流式输出。
-
----
+更多说明见 [docs/installation-troubleshooting.md](docs/installation-troubleshooting.md)。
## 参与贡献
-欢迎提交 Issue 和 Pull Request!
-
-1. Fork 本仓库并创建功能分支。
-2. 以开发模式启动应用(参见[方式三](#方式三开发模式))。
-3. 修改代码并运行对应的 Bun 质量门禁(后端改动运行 `make check`;前端/Electron 改动在 `taskboard-electron/` 下运行前端门禁)。
-4. 提交 PR,并清晰描述改动内容。
+1. Fork 仓库并创建功能分支。
+2. 使用 `cd taskboard-electron && bun run start` 启动开发模式。
+3. 保持改动聚焦,提交 PR 前运行相关质量门禁。
-**关键文件:**
-- `backend/` —— 整个 TypeScript 后端(数据库、调度器、执行器、HTTP API、频道)
-- `taskboard-electron/src/main.ts` —— Electron 主进程
-- `taskboard-electron/src/renderer/App.tsx` —— React 前端
-- `backend/src/channels/` —— 可插拔消息频道适配器
-- `skills/agentforge/` —— 用于智能体间委托的 Claude Code Skill
+关键文件:
----
+- `backend/` - Bun/TypeScript 后端、调度器、执行器、API 和渠道。
+- `taskboard-electron/src/main.ts` - Electron 主进程。
+- `taskboard-electron/src/renderer/App.tsx` - React 渲染进程。
+- `skills/agentforge/` - 智能体委派任务的内置技能。
## 许可证
-MIT —— 详见 [LICENSE](LICENSE)。
+MIT - 详见 [LICENSE](LICENSE)。
diff --git a/assets/readme-preview.svg b/assets/readme-preview.svg
new file mode 100644
index 0000000..61d6997
--- /dev/null
+++ b/assets/readme-preview.svg
@@ -0,0 +1,170 @@
+
diff --git a/assets/screenshot.png b/assets/screenshot.png
deleted file mode 100644
index 779e647..0000000
Binary files a/assets/screenshot.png and /dev/null differ