crewbee 0.1.12 → 0.1.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (96) hide show
  1. package/README.md +175 -269
  2. package/README.zh-CN.md +157 -271
  3. package/dist/opencode-plugin.mjs +351 -108
  4. package/dist/src/adapters/opencode/config-merge.d.ts.map +1 -1
  5. package/dist/src/adapters/opencode/config-merge.js +2 -1
  6. package/dist/src/adapters/opencode/config-merge.js.map +1 -1
  7. package/dist/src/adapters/opencode/delegation/resolve-agent.d.ts +1 -0
  8. package/dist/src/adapters/opencode/delegation/resolve-agent.d.ts.map +1 -1
  9. package/dist/src/adapters/opencode/delegation/resolve-agent.js +8 -2
  10. package/dist/src/adapters/opencode/delegation/resolve-agent.js.map +1 -1
  11. package/dist/src/adapters/opencode/delegation/tools.d.ts.map +1 -1
  12. package/dist/src/adapters/opencode/delegation/tools.js +14 -3
  13. package/dist/src/adapters/opencode/delegation/tools.js.map +1 -1
  14. package/dist/src/adapters/opencode/model-resolution.d.ts.map +1 -1
  15. package/dist/src/adapters/opencode/model-resolution.js +50 -10
  16. package/dist/src/adapters/opencode/model-resolution.js.map +1 -1
  17. package/dist/src/adapters/opencode/permission-mapper.d.ts.map +1 -1
  18. package/dist/src/adapters/opencode/permission-mapper.js +4 -1
  19. package/dist/src/adapters/opencode/permission-mapper.js.map +1 -1
  20. package/dist/src/adapters/opencode/projection.d.ts +14 -0
  21. package/dist/src/adapters/opencode/projection.d.ts.map +1 -1
  22. package/dist/src/adapters/opencode/projection.js +70 -1
  23. package/dist/src/adapters/opencode/projection.js.map +1 -1
  24. package/dist/src/adapters/opencode/prompt-builder.d.ts.map +1 -1
  25. package/dist/src/adapters/opencode/prompt-builder.js +12 -7
  26. package/dist/src/adapters/opencode/prompt-builder.js.map +1 -1
  27. package/dist/src/adapters/opencode/tool-hooks.d.ts +1 -1
  28. package/dist/src/adapters/opencode/tool-hooks.d.ts.map +1 -1
  29. package/dist/src/adapters/opencode/tool-hooks.js +22 -27
  30. package/dist/src/adapters/opencode/tool-hooks.js.map +1 -1
  31. package/dist/src/agent-teams/constants.d.ts +5 -0
  32. package/dist/src/agent-teams/constants.d.ts.map +1 -1
  33. package/dist/src/agent-teams/constants.js +6 -1
  34. package/dist/src/agent-teams/constants.js.map +1 -1
  35. package/dist/src/agent-teams/filesystem.d.ts +4 -1
  36. package/dist/src/agent-teams/filesystem.d.ts.map +1 -1
  37. package/dist/src/agent-teams/filesystem.js +116 -6
  38. package/dist/src/agent-teams/filesystem.js.map +1 -1
  39. package/dist/src/agent-teams/parsers.d.ts.map +1 -1
  40. package/dist/src/agent-teams/parsers.js +14 -2
  41. package/dist/src/agent-teams/parsers.js.map +1 -1
  42. package/dist/src/cli/doctor.js +1 -1
  43. package/dist/src/cli/doctor.js.map +1 -1
  44. package/dist/src/cli/package-version.d.ts.map +1 -0
  45. package/dist/src/cli/package-version.js.map +1 -0
  46. package/dist/src/cli/version.js +1 -1
  47. package/dist/src/cli/version.js.map +1 -1
  48. package/dist/src/core/index.d.ts +2 -0
  49. package/dist/src/core/index.d.ts.map +1 -1
  50. package/dist/src/install/types.d.ts +1 -1
  51. package/dist/src/install/types.d.ts.map +1 -1
  52. package/dist/src/normalize/build-agent-prompt-document.d.ts +6 -0
  53. package/dist/src/normalize/build-agent-prompt-document.d.ts.map +1 -0
  54. package/dist/src/normalize/{build-agent-prompt-source.js → build-agent-prompt-document.js} +6 -6
  55. package/dist/src/normalize/build-agent-prompt-document.js.map +1 -0
  56. package/dist/src/normalize/{build-team-prompt-source.d.ts → build-team-prompt-document.d.ts} +2 -2
  57. package/dist/src/normalize/build-team-prompt-document.d.ts.map +1 -0
  58. package/dist/src/normalize/{build-team-prompt-source.js → build-team-prompt-document.js} +3 -3
  59. package/dist/src/normalize/build-team-prompt-document.js.map +1 -0
  60. package/dist/src/render/apply-prompt-projection.d.ts.map +1 -0
  61. package/dist/src/render/apply-prompt-projection.js.map +1 -0
  62. package/dist/src/render/build-prompt-catalog.d.ts.map +1 -0
  63. package/dist/src/render/build-prompt-catalog.js.map +1 -0
  64. package/dist/src/render/build-prompt-plan.d.ts.map +1 -0
  65. package/dist/src/render/build-prompt-plan.js.map +1 -0
  66. package/dist/src/render/prompt-document-renderer.js +3 -3
  67. package/dist/src/render/prompt-document-renderer.js.map +1 -1
  68. package/dist/src/render/structural-renderer.js +1 -1
  69. package/dist/src/render/structural-renderer.js.map +1 -1
  70. package/package.json +2 -2
  71. package/templates/crewbee.json +1 -0
  72. package/dist/src/catalog/build-prompt-catalog.d.ts.map +0 -1
  73. package/dist/src/catalog/build-prompt-catalog.js.map +0 -1
  74. package/dist/src/manager/index.d.ts +0 -24
  75. package/dist/src/manager/index.d.ts.map +0 -1
  76. package/dist/src/manager/index.js +0 -68
  77. package/dist/src/manager/index.js.map +0 -1
  78. package/dist/src/normalize/build-agent-prompt-source.d.ts +0 -6
  79. package/dist/src/normalize/build-agent-prompt-source.d.ts.map +0 -1
  80. package/dist/src/normalize/build-agent-prompt-source.js.map +0 -1
  81. package/dist/src/normalize/build-team-prompt-source.d.ts.map +0 -1
  82. package/dist/src/normalize/build-team-prompt-source.js.map +0 -1
  83. package/dist/src/plan/build-prompt-plan.d.ts.map +0 -1
  84. package/dist/src/plan/build-prompt-plan.js.map +0 -1
  85. package/dist/src/projection/apply-prompt-projection.d.ts.map +0 -1
  86. package/dist/src/projection/apply-prompt-projection.js.map +0 -1
  87. package/dist/src/version/package-version.d.ts.map +0 -1
  88. package/dist/src/version/package-version.js.map +0 -1
  89. /package/dist/src/{version → cli}/package-version.d.ts +0 -0
  90. /package/dist/src/{version → cli}/package-version.js +0 -0
  91. /package/dist/src/{projection → render}/apply-prompt-projection.d.ts +0 -0
  92. /package/dist/src/{projection → render}/apply-prompt-projection.js +0 -0
  93. /package/dist/src/{catalog → render}/build-prompt-catalog.d.ts +0 -0
  94. /package/dist/src/{catalog → render}/build-prompt-catalog.js +0 -0
  95. /package/dist/src/{plan → render}/build-prompt-plan.d.ts +0 -0
  96. /package/dist/src/{plan → render}/build-prompt-plan.js +0 -0
package/README.md CHANGED
@@ -2,42 +2,51 @@
2
2
 
3
3
  [English](README.md) | [简体中文](README.zh-CN.md)
4
4
 
5
- <p align="center">
6
- <img src="assets/crewbee-intro.png" alt="Turn scattered agents into real teams" width="100%" />
7
- </p>
5
+ > [!NOTE]
6
+ >
7
+ > [![CrewBee - Turn scattered agents into real teams.](./assets/web-home-en.png?v=2)](https://crewbeelab.github.io)
8
+ > > **CrewBee turns prompts, agents, rules, review flows, and completion criteria into maintainable Agent Team assets. <br />Visit the website [here](https://crewbeelab.github.io).**
9
+
10
+
11
+ CrewBee is an **Agent Team asset layer** with OpenCode as its first officially supported host.
8
12
 
9
- <p align="center"><strong>An Agent Team framework for OpenCode.</strong></p>
13
+ It turns prompts, agents, rules, review flows, and completion criteria in engineering work into maintainable **Agent Team assets**.
10
14
 
11
- CrewBee lets you design different **Agent Teams** for different tasks or projects, and switch flexibly between **single-agent execution** and **multi-agent collaboration** based on task complexity.
15
+ CrewBee helps you build reusable Agent Teams for specialized workflows: not just agents, but tools / skills strategies, workflows, rules, review flows, and completion criteria.
12
16
 
13
- It is not a prompt pack or a forced multi-agent ritual. CrewBee turns agent roles, collaboration patterns, context management, review flow, completion criteria, and host adaptation into maintainable, runnable, and reusable Team engineering assets.
17
+ Here, “team” does not mean enabling more agents by default. It means giving complex engineering work clear responsibilities and collaboration boundaries across requirements understanding, codebase exploration, implementation planning, implementation changes, independent review, validation, and delivery notes.
14
18
 
15
- **Current focus:** make Team-level agent systems clearly definable, projectable across host runtimes, and runnable inside OpenCode.
19
+ Not a prompt pack.
20
+ Not a flat agent list.
21
+ Not another all-in-one multi-agent runtime.
22
+
23
+ **Available for OpenCode today.** OpenCode is CrewBee’s first officially supported host; Project Context, the Team template ecosystem, and more Agent Harness adapters are next-stage directions.
16
24
 
17
25
  ---
18
26
 
19
27
  ## Why CrewBee
20
28
 
21
- * **Design different Agent Teams for different tasks or projects** — Different work can have different roles, rules, workflows, and completion criteria.
22
- * **Switch between single-agent and multi-agent collaboration based on task complexity** — Keep simple tasks fast and lightweight; use Team collaboration, support agents, review, and verification for complex tasks.
23
- * **Keep the main agent as the owner of the most complete context** — The main agent holds the user goal, project constraints, support findings, review feedback, and verification results, so key decisions are based on fuller evidence.
24
- * **Use context-isolated delegation** — Support agents work in dedicated contexts for exploration, research, and review, then return high-signal findings to the main agent. This reduces the main agent’s context and attention load.
25
- * **Built-in mature Coding Team** — CrewBee includes a Coding Team with clear role responsibilities, review flow, and completion criteria for development, debugging, refactoring, and verification work.
26
- * **Project Context direction across sessions** — Next, CrewBee will strengthen automatically maintained project context, so long-running projects can keep summaries of project positioning, framework design, history, current state, and plans across sessions.
27
- * **Copyable, modifiable, and contributable Team templates** — Teams are engineering assets that can be refined, versioned, and shared.
29
+ Complex engineering tasks need a reviewable, verifiable work structure.
28
30
 
29
- CrewBee has already completed the **CrewBee → OpenCode** MVP path:
31
+ Code generation is only one part of delivery. What matters is requirements understanding, codebase exploration, implementation planning, implementation changes, independent review, validation, and delivery notes.
30
32
 
31
- * Host-agnostic Team / Agent definitions
32
- * Team Library assembly and validation
33
- * Runtime Projection and formal leader default selection
34
- * OpenCode agent config projection, aliases, config patches, and session binding
35
- * OpenCode plugin entry, delegation tools, event wiring, and system prompt injection
36
- * Local build, user-level installation, doctor checks, and uninstall flow
33
+ When these concerns are scattered across prompts, agents, rules, review checklists, and ad-hoc conventions, agent work becomes hard to maintain, reuse, and improve.
37
34
 
38
- > Simple mental model:
39
- >
40
- > **CrewBee = Agent Team definition framework + Runtime Projection layer + Host adapter layer, currently for OpenCode**
35
+ ### CrewBee in OpenCode
36
+
37
+ The screenshot below shows CrewBee running inside OpenCode, with the Coding Team entry selected and review-backed work visible in the session.
38
+
39
+ ![CrewBee running inside OpenCode desktop](./assets/opencode-desktop.png?v=2)
40
+
41
+ CrewBee focuses on three current product differentiators:
42
+
43
+ * **Agent Team assets** — Turn prompts, agents, rules, review flows, and completion criteria into maintainable Team assets.
44
+ * **Reusable Agent Teams for specialized workflows** — Build Team definitions for domain-specific work, including agents, tools / skills strategies, workflows, rules, review flows, and completion criteria.
45
+ * **Built-in Coding Team** — Start from an owner-centered, review-backed Coding Team for development, fixing, debugging, refactoring, validation, and delivery notes.
46
+
47
+ CrewBee does not make multi-agent collaboration a default ritual.
48
+
49
+ Simple tasks stay lightweight. Complex tasks get support, review, validation, and completion criteria.
41
50
 
42
51
  ---
43
52
 
@@ -76,7 +85,7 @@ The same id is used for OpenCode `default_agent`, explicitly selected agents in
76
85
  * [Quick Start](#quick-start)
77
86
  * [Agent Team and Agent Profile Definitions](#agent-team-and-agent-profile-definitions)
78
87
  * [How the OpenCode Runtime Works](#how-the-opencode-runtime-works)
79
- * [Built-in Coding Team Design](#built-in-coding-team-design)
88
+ * [Built-in Coding Team](#built-in-coding-team)
80
89
  * [Next: Project Context](#next-project-context)
81
90
  * [Configuration, Installation, and Operations Scripts](#configuration-installation-and-operations-scripts)
82
91
  * [Uninstall](#uninstall)
@@ -86,314 +95,173 @@ The same id is used for OpenCode `default_agent`, explicitly selected agents in
86
95
 
87
96
  ## What CrewBee Is
88
97
 
89
- CrewBee is an Agent Team framework for real host runtimes.
98
+ CrewBee is an **Agent Team asset layer** with OpenCode as its first officially supported host.
90
99
 
91
- In CrewBee, the first-class object is not a single Agent, but a **Team**. A Team is not a concatenation of prompt fragments. It is a structured definition unit that includes at least:
100
+ In CrewBee, the first-class object is not a single agent or a prompt fragment, but an **Agent Team asset**.
92
101
 
93
- * Team identity and positioning
94
- * formal leader
102
+ An Agent Team asset can include:
103
+
104
+ * Team mission and scope
105
+ * formal Leader
95
106
  * members
107
+ * shared policy
96
108
  * workflow
97
- * Team-level shared rules
109
+ * review flow
110
+ * completion criteria
98
111
  * Agent Profiles
99
- * Prompt Projection
100
- * host runtime mapping
101
-
102
- CrewBee aims to turn scattered agent prompts, rules, and collaboration conventions into maintainable, portable, and runnable Team assets.
112
+ * tools / skills strategy
113
+ * model preferences
114
+ * host binding
103
115
 
104
- The current usage model is:
116
+ The goal is to turn a reusable way of working into a maintainable Team asset.
105
117
 
106
- * The user selects a Team entry agent in the host runtime.
107
- * CrewBee projects the Team definition into the host runtime in a stable way.
108
- * At runtime, CrewBee preserves Team semantics through session binding, delegation, and system prompt injection.
118
+ CrewBee does not replace OpenCode and does not try to become another all-in-one multi-agent runtime. Its current focus is to organize specialized engineering workflows into reusable Agent Teams and make the built-in Coding Team available in OpenCode.
109
119
 
110
- CrewBee does not currently force automatic Team selection or automatically decide the organization structure for every task. It first focuses on making Team definitions, Team projection, runtime binding, and OpenCode adaptation solid.
120
+ CrewBee projects Team assets into OpenCode so they can run in the host environment. Runtime Projection, OpenCode Adapter, setup, doctor checks, per-agent model configuration, and projection-time fallback are implementation and usability supports, not the long-term product differentiators described above.
111
121
 
112
122
  ---
113
123
 
114
124
  ## What CrewBee Solves
115
125
 
116
- CrewBee mainly solves seven problems.
126
+ CrewBee mainly solves the problem of turning scattered agent work into maintainable Team assets.
117
127
 
118
- ### 1. Design different Agent Teams for different tasks or projects
128
+ ### 1. Scattered prompts, agents, and rules are hard to maintain
119
129
 
120
- Coding, research, writing, analysis, marketing, and long-running project maintenance are not the same kind of work. They need different role structures, working rules, tool boundaries, review flows, and completion criteria.
130
+ Many AI coding setups start with a prompt, a few custom agents, some project rules, and a review checklist.
121
131
 
122
- CrewBee lets you design different Agent Teams for different tasks or projects instead of using one increasingly long general-purpose prompt for everything.
132
+ Over time, these pieces become scattered across projects and host-specific configuration. They are hard to reuse, version, review, and improve.
123
133
 
124
- ### 2. Switch flexibly between single-agent and multi-agent collaboration based on task complexity
134
+ CrewBee turns them into maintainable Agent Team assets.
125
135
 
126
- Simple tasks need fast responses, fewer tokens, and fewer steps. Complex tasks need support agents, independent review, verification, and clearer completion gates.
136
+ ### 2. Complex engineering tasks need a reviewable, verifiable work structure
127
137
 
128
- CrewBee is not designed to turn every task into multi-agent collaboration by default. It is designed to choose the right execution mode based on task complexity.
138
+ Reliable software delivery is not only code generation.
129
139
 
130
- ### 3. Keep the main agent as the owner of the most complete context
140
+ Complex tasks often involve requirements understanding, codebase exploration, implementation planning, implementation changes, independent review, validation, and delivery notes.
131
141
 
132
- In complex tasks, codebase exploration, external research, review, and verification may all produce important information.
142
+ CrewBee organizes these responsibilities into a Team structure instead of leaving them in ad-hoc prompts.
133
143
 
134
- CrewBee keeps the main agent / formal leader as the owner of the most complete task context. The main agent collects the user goal, project constraints, support findings, review feedback, and verification results before making key decisions and closing the task.
144
+ ### 3. Specialized workflows need reusable Agent Teams
135
145
 
136
- ### 4. Reduce the main agent’s context and attention load through context-isolated delegation
146
+ Different work needs different responsibilities, tools, rules, review flows, and completion criteria.
137
147
 
138
- Complex work should not dump every search trace, side exploration, failed path, and low-signal detail into the main agent’s context.
148
+ CrewBee helps you build reusable Agent Teams for specialized workflows: coding, code review, documentation, release work, research, bug triage, or other domain-specific work.
139
149
 
140
- CrewBee uses delegation so support agents can work in dedicated contexts for codebase exploration, research, review, or multimodal interpretation, then return high-signal findings to the main agent. This reduces main-context pollution and the main agent’s attention load.
150
+ This is not a mature template marketplace today. The current value is the engineering ability to define and run reusable Team assets.
141
151
 
142
- ### 5. Built-in mature Coding Team with review flow and completion criteria
152
+ ### 4. Complex coding tasks should not depend on a single Coder self-declaring completion
143
153
 
144
- Coding tasks need more than code generation. They need codebase exploration, external research, independent review, verification evidence, and completion criteria.
154
+ The built-in Coding Team is CrewBee’s flagship sample.
145
155
 
146
- CrewBee’s built-in Coding Team uses direct responsibility-based role names and emphasizes review and completion criteria, helping complex coding tasks reach a more reliable closure.
156
+ It gives complex coding tasks a clearer structure:
147
157
 
148
- ### 6. Project Context direction across sessions
149
-
150
- Long-running projects should not require the user to re-explain project positioning, framework design, history, current state, and next steps every time a new session starts.
158
+ ```text
159
+ Main Owner
160
+ + Codebase Exploration
161
+ + Focused Implementation
162
+ + Independent Review
163
+ + Completion Criteria
164
+ ```
151
165
 
152
- CrewBee’s next stage will strengthen automatically maintained Project Context, so agents can use project summaries to read code heuristically and reduce the context cost of repeatedly scanning the whole codebase.
166
+ The goal is not more agents by default. The goal is clearer ownership, better evidence, independent review, and more reliable completion.
153
167
 
154
- ### 7. Copyable, modifiable, and contributable Team templates
168
+ ### 5. Simple tasks should stay lightweight
155
169
 
156
- A Team is not just internal configuration. It is an engineering asset that can be copied, modified, versioned, and contributed.
170
+ CrewBee does not turn every task into a full Team workflow.
157
171
 
158
- This lets users start from built-in Teams or templates, then gradually build their own agent workflows.
172
+ Simple tasks should stay lightweight. Complex tasks can use support roles, review, validation, and completion criteria when needed.
159
173
 
160
174
  ---
161
175
 
162
176
  ## Core Features
163
177
 
164
- ### 1. Design different Agent Teams for different tasks or projects
178
+ ### 1. Agent Team assets
165
179
 
166
- CrewBee treats Team as a first-class object rather than focusing only on scattered agent prompts.
180
+ CrewBee turns prompts, agents, rules, review flows, and completion criteria into maintainable Team assets.
167
181
 
168
- A Team can have its own:
182
+ A Team asset can define:
169
183
 
170
- * task positioning
171
- * default entry agent
172
- * member responsibilities
184
+ * mission and scope
185
+ * formal Leader
186
+ * members
173
187
  * workflow
174
188
  * shared rules
175
- * tool boundaries
189
+ * tools / skills strategy
176
190
  * review flow
177
191
  * completion criteria
178
- * output style
179
-
180
- This means you can design different Teams for different tasks or projects, such as:
181
-
182
- * `CodingTeam`: development, fixing, debugging, refactoring, verification
183
- * `GeneralTeam`: research, analysis, writing, planning
184
- * `ResearchOpsTeam`: evidence retrieval, material organization, conclusion synthesis
185
- * `MarketingOpsTeam`: open-source release, promotion, community feedback
186
- * `ProjectContextTeam`: project context maintenance, state updates, cross-session handoff
187
- * `WukongTeam`: high-uncertainty exploration and long-running complex tasks
188
-
189
- ### 2. Switch between single-agent and multi-agent collaboration based on task complexity
190
-
191
- CrewBee does not make multi-agent collaboration a default ritual. It supports choosing different execution modes based on task complexity.
192
-
193
- **Single-agent execution** fits:
194
-
195
- * simple questions
196
- * small code changes
197
- * local explanations
198
- * quick summarization
199
- * low-risk tasks
200
- * tasks with clear context and clear goals
201
-
202
- **Multi-agent collaboration** fits:
203
-
204
- * cross-file implementation
205
- * complex bug fixes
206
- * external research
207
- * architecture decisions
208
- * independent review
209
- * tasks requiring verification evidence
210
- * long-running project work
211
-
212
- Simple tasks stay fast. Complex tasks use Team collaboration.
213
-
214
- ### 3. Main agent owns the most complete context for fuller decisions
215
-
216
- CrewBee Teams use the main agent / formal leader as the task entry point, mainline owner, and final closer.
217
-
218
- The main agent holds the most complete task context, including:
219
-
220
- * user goal
221
- * project constraints
222
- * current task state
223
- * findings returned by support agents
224
- * review feedback
225
- * verification results
226
- * risks and unresolved items
227
-
228
- Key decisions are made by the main agent based on this combined context, instead of being made globally by support agents that only hold partial information.
229
-
230
- ### 4. Context-isolated delegation reduces the main agent’s context and attention load
231
-
232
- CrewBee’s support collaboration emphasizes context-isolated delegation:
233
-
234
- ```text
235
- The main agent owns the main task context.
236
- Support agents work on specialized tasks in dedicated contexts.
237
- Support agents return high-signal findings to the main agent.
238
- The main agent continues decision-making and final closure based on those findings.
239
- ```
192
+ * output contract
193
+ * model preferences
194
+ * host binding
240
195
 
241
- Support tasks include:
196
+ This makes the Team maintainable, reusable, and easier to evolve than scattered prompts or flat agent lists.
242
197
 
243
- * codebase exploration
244
- * external documentation research
245
- * evidence organization
246
- * multimodal interpretation
247
- * independent review
248
- * high-level architecture advice
198
+ ### 2. Reusable Agent Teams for specialized workflows
249
199
 
250
- This prevents side searches, failed paths, low-signal material, and review traces from polluting the main context.
200
+ CrewBee lets you define Agent Teams for specialized workflows.
251
201
 
252
- ### 5. Built-in mature Coding Team with review flow and completion criteria
202
+ A specialized Team is not just a group of agents. It can also include tools / skills strategies, workflows, rules, review flows, and completion criteria.
253
203
 
254
- CrewBee’s most important methodology sample today is the built-in Coding Team.
204
+ Examples of possible Team directions include:
255
205
 
256
- It is not a single Coder Agent, but an Agent Team designed for software engineering work. The recommended structure includes:
206
+ * Coding Team
207
+ * Code Review Team
208
+ * ResearchOps Team
209
+ * Documentation Team
210
+ * ReleaseOps Team
211
+ * Bug Triage Team
212
+ * MarketingOps Team
213
+ * Product Planning Team
257
214
 
258
- ```text
259
- coding-leader
260
- coding-executor
261
- codebase-explorer
262
- web-researcher
263
- reviewer
264
- principal-advisor
265
- multimodal-looker
266
- task-orchestrator
267
- ```
215
+ These are examples of what CrewBee’s Team asset model is designed to support. A broader Team template ecosystem is a roadmap direction, not a mature ecosystem today.
268
216
 
269
- The built-in Coding Team uses direct responsibility-based role names so users can quickly understand what each agent does.
217
+ ### 3. Built-in Coding Team
270
218
 
271
- | Built-in Coding Team Role | Responsibility |
272
- | ------------------------- | --------------------------------------------------------------------------------------------------- |
273
- | `coding-leader` | Default entry point, task owner, and final closer |
274
- | `coding-executor` | Implements clear development, fixing, debugging, and local refactoring tasks |
275
- | `codebase-explorer` | Locates code entry points, call chains, similar implementations, and historical clues |
276
- | `web-researcher` | Researches official docs, external references, open-source implementations, and version differences |
277
- | `reviewer` | Independently reviews risks, omissions, verification evidence, and completion criteria |
278
- | `principal-advisor` | Provides high-level advice on architecture, performance, and complexity decisions |
279
- | `multimodal-looker` | Interprets screenshots, charts, PDFs, UI images, and visual materials |
280
- | `task-orchestrator` | Handles large plans, multi-wave tasks, and unified QA orchestration |
219
+ CrewBee includes a built-in Coding Team as its current flagship sample.
281
220
 
282
- Completion in the Coding Team should not depend only on “the agent thinks it is done.” It should include explicit completion criteria whenever possible, such as:
221
+ It is designed for owner-centered, review-backed coding:
283
222
 
284
223
  ```text
285
- - The target issue has been located.
286
- - The change has a clear rationale.
287
- - The required implementation or fix has been completed.
288
- - Available diagnostics / build / tests have been run.
289
- - The reviewer found no real blocking issue.
290
- - Unverified items and residual risks have been stated.
224
+ Main Owner
225
+ + Codebase Exploration
226
+ + Focused Implementation
227
+ + Independent Review
228
+ + Completion Criteria
291
229
  ```
292
230
 
293
- ### 6. Host-agnostic definitions and OpenCode Runtime Projection
294
-
295
- CrewBee first converts the Team-first structure into a unified intermediate representation, then maps it into concrete host runtimes.
296
-
297
- The current primary host is OpenCode.
298
-
299
- The current OpenCode MVP path includes:
300
-
301
- * Team Library loading
302
- * Team / Agent validation
303
- * Runtime Projection
304
- * formal leader default selection
305
- * projected agent generation
306
- * OpenCode config patch
307
- * session binding
308
- * delegation tooling
309
- * plugin entry
310
- * user-level install
311
- * doctor verification
312
-
313
- This makes CrewBee more than a prompt folder. It is a runtime framework that can actually plug into OpenCode.
231
+ This helps complex coding tasks avoid depending only on a single Coder agent self-declaring completion.
314
232
 
315
- ### 7. Copyable, modifiable, and contributable Team templates
233
+ ### 4. Lightweight path for simple tasks, support path for complex tasks
316
234
 
317
- CrewBee Teams are file-based engineering assets that can be copied, modified, versioned, and contributed.
235
+ CrewBee does not make multi-agent collaboration a default ritual.
318
236
 
319
- Users can:
237
+ Simple tasks can stay lightweight. Complex tasks can use support agents, review, validation, and completion criteria when needed.
320
238
 
321
- * use built-in Teams
322
- * copy Team templates
323
- * modify role structures
324
- * adjust shared rules
325
- * encode their own workflow
326
- * contribute Teams back to the community
239
+ ### 5. OpenCode usability support
327
240
 
328
- Many users may not modify CrewBee core, but they can still start from a template and build their own Team.
241
+ CrewBee is available for OpenCode today.
329
242
 
330
- ### 8. Prompts are decoupled while preserving execution semantics
243
+ The current OpenCode path includes user-level setup, doctor checks, OpenCode configuration support, delegation tooling, and per-agent model configuration.
331
244
 
332
- CrewBee does not fall back to an old pattern where every field needs a dedicated schema and renderer. It also does not simply dump every top-level block into the prompt.
245
+ These are productization and usability supports. They help users install, run, configure, and diagnose CrewBee, but they are not CrewBee’s long-term core differentiators.
333
246
 
334
- The current approach is:
247
+ ### 6. Implementation details that support Team assets
335
248
 
336
- > **a small set of shared semantic sections + generic structural processing + structured rendering**
249
+ CrewBee also includes implementation details that make Team assets runnable and usable in OpenCode:
337
250
 
338
- For example, the Agent prompt skeleton is organized around execution cognition:
251
+ * Prompt Projection keeps Agent prompts structured while preserving execution semantics.
252
+ * Collaboration sections generate runtime-usable delegation targets.
253
+ * Team Contract rendering compresses policy into `Working Rules` and `Approval & Safety`.
254
+ * Team assets can be copied, modified, and versioned.
339
255
 
340
- * Persona Core
341
- * Responsibility Core
342
- * Core Principle
343
- * Scope Control
344
- * Ambiguity Policy
345
- * Support Triggers
346
- * Collaboration
347
- * Task Triage
348
- * Delegation & Review
349
- * Todo Discipline
350
- * Completion Gate
351
- * Failure Recovery
352
- * Operations
353
- * Output Contract
354
- * Templates
355
- * Guardrails
356
- * Heuristics
357
- * Anti Patterns
358
- * Tool Skill Strategy
256
+ These details are important for implementation quality, but they are not the three main product differentiators.
359
257
 
360
- This helps the model quickly establish:
258
+ ### 7. Roadmap directions
361
259
 
362
- * who I am
363
- * what I am responsible for
364
- * how I act by default
365
- * when to delegate / review / ask / stop
366
- * what counts as completion
367
- * how to recover from failure
260
+ The following are next-stage directions, not mature current advantages:
368
261
 
369
- ### 9. Collaboration generates runtime-usable delegation targets
370
-
371
- The generated `Collaboration` section is not just a simple list of collaboration bindings from the profile. It combines:
372
-
373
- * subagent collaboration declarations from the Agent Profile
374
- * `members` descriptions from the Team Manifest
375
- * projected ids that OpenCode can resolve
376
-
377
- Then it generates:
378
-
379
- * `Id`
380
- * `Description`
381
- * `When To Delegate`
382
-
383
- This makes delegation targets directly usable at runtime.
384
-
385
- ### 10. Team Contract is compressed into an executable handbook
386
-
387
- The Team prompt does not mechanically render the entire governance config. It is compressed into:
388
-
389
- * `Working Rules`
390
- * `Approval & Safety`
391
-
392
- This makes the Team contract easier for the model to consume and avoids mechanical expansion of governance fields.
393
-
394
- ### 11. User-level installation and operations flow
395
-
396
- CrewBee already has a complete local build, user-level installation, doctor verification, and uninstall flow, so it can be installed as a user-level OpenCode plugin.
262
+ * Project Context for long-running, cross-session project work.
263
+ * A broader Team template ecosystem.
264
+ * More Agent Harness adapters and multi-host projection experiments.
397
265
 
398
266
  ---
399
267
 
@@ -430,6 +298,8 @@ Select `coding-leader` and run your first real task:
430
298
  Use CrewBee Coding Team to fix this issue with review-backed completion.
431
299
  ```
432
300
 
301
+ The first recommended experience is to open a real project in OpenCode, select `coding-leader`, and run a coding task with review-backed completion.
302
+
433
303
  Verify anytime:
434
304
 
435
305
  ```bash
@@ -612,6 +482,8 @@ Constraints:
612
482
 
613
483
  ## How the OpenCode Runtime Works
614
484
 
485
+ This section explains the current OpenCode implementation path. Runtime Projection, OpenCode configuration patches, session binding, and delegation tooling are implementation details that make CrewBee’s Team assets runnable in OpenCode; they are not the main product differentiators described above.
486
+
615
487
  The current OpenCode plugin path is roughly:
616
488
 
617
489
  ```text
@@ -662,13 +534,38 @@ Injects minimal CrewBee runtime information into the system prompt:
662
534
 
663
535
  ---
664
536
 
665
- ## Built-in Coding Team Design
537
+ ## Built-in Coding Team
538
+
539
+ CrewBee’s built-in Coding Team is the current flagship sample of the Agent Team asset model.
540
+
541
+ It is designed for owner-centered, review-backed coding work:
542
+
543
+ ```text
544
+ Main Owner
545
+ + Codebase Exploration
546
+ + Focused Implementation
547
+ + Independent Review
548
+ + Completion Criteria
549
+ ```
550
+
551
+ The value is not that there are more coding agents. The value is that complex coding tasks get clearer ownership, code evidence, implementation focus, independent review, validation, and delivery notes.
552
+
553
+ The built-in Coding Team uses direct responsibility-based role names so users can quickly understand what each agent does.
666
554
 
667
- CrewBee’s most important methodology sample today is the built-in Coding Team.
555
+ | Built-in Coding Team Role | Responsibility |
556
+ | ------------------------- | --------------------------------------------------------------------------------------------------- |
557
+ | `coding-leader` | Default entry, task owner, decision context owner, and final handoff |
558
+ | `coding-executor` | Focused implementation, fixes, debugging, and local refactoring |
559
+ | `codebase-explorer` | Code entry points, call chains, related implementations, and historical clues |
560
+ | `web-researcher` | Official docs, external references, open-source implementations, and version differences |
561
+ | `reviewer` | Independent review of risks, omissions, verification evidence, and completion criteria |
562
+ | `principal-advisor` | Architecture, performance, and complexity advice |
563
+ | `multimodal-looker` | Screenshots, charts, PDFs, UI images, and visual materials |
564
+ | `task-orchestrator` | Large plans, multi-wave tasks, and unified QA orchestration |
668
565
 
669
566
  ### 1. The main agent owns the most complete context
670
567
 
671
- The Coding Team’s main agent / formal leader is the default entry point, mainline owner, and final closer.
568
+ The Coding Team’s main agent / formal leader is the default entry point, mainline owner, decision context owner, and final handoff owner.
672
569
 
673
570
  It collects:
674
571
 
@@ -722,16 +619,21 @@ For coding tasks, CrewBee emphasizes:
722
619
  * Principal Advisor provides high-level judgment when needed
723
620
  * the main agent receives high-signal findings, then decides and closes the task
724
621
 
622
+ The Coding Team should prove one thing first: complex coding tasks can be organized as a reusable Team asset, instead of being handled by a single Coder agent that writes code and declares the task done.
623
+
725
624
  ---
726
625
 
727
626
  ## Next: Project Context
728
627
 
729
- Project Context is an important next-stage product direction for CrewBee.
628
+ Project Context is a next-stage product direction for CrewBee.
629
+
630
+ It should not be understood as a fully mature feature today.
631
+
632
+ The goal is to help long-running projects avoid making agents onboard from zero in every new session.
730
633
 
731
- Its goal is to automatically maintain project context across sessions, so long-running projects keep high-signal summary information, including:
634
+ A future Project Context capability should maintain high-signal project information such as:
732
635
 
733
636
  * project positioning
734
- * framework design
735
637
  * architecture summary
736
638
  * key history
737
639
  * current implementation state
@@ -852,8 +754,12 @@ npm run doctor
852
754
 
853
755
  ## Acknowledgements
854
756
 
855
- CrewBee is inspired by OpenCode and community projects such as oh-my-openagent. These projects explored the value of Agent Team workflows in real development environments and helped more developers see the potential of multi-agent collaboration.
757
+ CrewBee is built with appreciation for OpenCode and the broader open-source agent ecosystem.
758
+
759
+ OpenCode is CrewBee’s first officially supported host and provides the runtime environment where CrewBee’s current Coding Team can be used.
760
+
761
+ Community projects such as oh-my-openagent have also helped more developers explore real-world agent workflows in OpenCode and related environments.
856
762
 
857
- Thanks to their developers and maintainers.
763
+ CrewBee continues from a different layer: organizing prompts, agents, rules, review flows, and completion criteria into maintainable Agent Team assets.
858
764
 
859
- CrewBee continues in this direction by organizing Agent Teams from prompt fragments or role configurations into manageable, projectable, configurable, and reusable engineering assets, so Agent Teams for different tasks or projects can be defined, run, and evolved more clearly.
765
+ Thanks to the developers, maintainers, and community members who keep pushing the open-source agent ecosystem forward.