mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-03-06 16:31:12 +08:00
feat: Add coordinator commands and role specifications for UI design team
- Implemented the 'monitor' command for coordinator role to handle monitoring events, task completion, and pipeline management. - Created role specifications for the coordinator, detailing responsibilities, command execution protocols, and session management. - Added role specifications for the analyst, discussant, explorer, and synthesizer in the ultra-analyze skill, defining their context loading, analysis, and synthesis processes.
This commit is contained in:
catlog22
@@ -116,10 +116,10 @@ Every worker executes the same task discovery flow on startup:
|
||||
Standard reporting flow after task completion:
|
||||
|
||||
1. **Message Bus**: Call `mcp__ccw-tools__team_msg` to log message
|
||||
- Parameters: operation="log", team=**<session-id>**, from=<role>, to="coordinator", type=<message-type>, summary="[<role>] <summary>", ref=<artifact-path>
|
||||
- **CLI fallback**: When MCP unavailable → `ccw team log --team <session-id> --from <role> --to coordinator --type <type> --summary "[<role>] ..." --json`
|
||||
- **Note**: `team` must be session ID (e.g., `ISS-xxx-date`), NOT team name. Extract from `Session:` field in task description.
|
||||
2. **SendMessage**: Send result to coordinator (content and summary both prefixed with `[<role>]`)
|
||||
- Parameters: operation="log", session_id=<session-id>, from=<role>, type=<message-type>, data={ref: "<artifact-path>"}
|
||||
- `to` and `summary` auto-defaulted -- do NOT specify explicitly
|
||||
- **CLI fallback**: `ccw team log --session-id <session-id> --from <role> --type <type> --json`
|
||||
2. **SendMessage**: Send result to coordinator
|
||||
3. **TaskUpdate**: Mark task completed
|
||||
4. **Loop**: Return to Phase 1 to check next task
|
||||
|
||||
@@ -158,11 +158,12 @@ All outputs must carry `[role_name]` prefix in both SendMessage content/summary
|
||||
|
||||
Every SendMessage **before**, must call `mcp__ccw-tools__team_msg` to log:
|
||||
|
||||
**Parameters**: operation="log", team=**<session-id>**, from=<role>, to="coordinator", type=<message-type>, summary="[<role>] <summary>", ref=<artifact-path>
|
||||
**Parameters**: operation="log", session_id=<session-id>, from=<role>, type=<message-type>, data={ref: "<artifact-path>"}
|
||||
|
||||
**CLI fallback**: When MCP unavailable → `ccw team log --team <session-id> --from <role> --to coordinator --type <type> --summary "[<role>] ..." --json`
|
||||
`to` and `summary` auto-defaulted -- do NOT specify explicitly.
|
||||
|
||||
**CLI fallback**: `ccw team log --session-id <session-id> --from <role> --type <type> --json`
|
||||
|
||||
**Note**: `team` must be session ID (e.g., `ISS-xxx-date`), NOT team name. Extract from `Session:` field in task description.
|
||||
|
||||
**Message types by role**:
|
||||
|
||||
@@ -399,8 +400,9 @@ Skill(skill="team-issue", args="--role=<role> --agent-name=<role>-<N>")
|
||||
|
||||
```
|
||||
.workflow/.team-plan/issue/
|
||||
├── team-session.json # Session state
|
||||
├── shared-memory.json # Cross-role state
|
||||
├── .msg/
|
||||
│ ├── messages.jsonl # Message bus log
|
||||
│ └── meta.json # Session state + cross-role state
|
||||
├── wisdom/ # Cross-task knowledge
|
||||
│ ├── learnings.md
|
||||
│ ├── decisions.md
|
||||
|
||||
105
.claude/skills/team-issue/role-specs/explorer.md
Normal file
105
.claude/skills/team-issue/role-specs/explorer.md
Normal file
@@ -0,0 +1,105 @@
|
||||
---
|
||||
prefix: EXPLORE
|
||||
inner_loop: false
|
||||
subagents: [cli-explore-agent]
|
||||
message_types:
|
||||
success: context_ready
|
||||
error: error
|
||||
---
|
||||
|
||||
# Issue Explorer
|
||||
|
||||
Analyze issue context, explore codebase for relevant files, map dependencies and impact scope. Produce a shared context report for planner, reviewer, and implementer.
|
||||
|
||||
## Phase 2: Issue Loading & Context Setup
|
||||
|
||||
| Input | Source | Required |
|
||||
|-------|--------|----------|
|
||||
| Issue ID | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
|
||||
| Issue details | `ccw issue status <id> --json` | Yes |
|
||||
| Session path | Extracted from task description | Yes |
|
||||
| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
|
||||
|
||||
1. Extract issue ID from task description via regex: `(?:GH-\d+|ISS-\d{8}-\d{6})`
|
||||
2. If no issue ID found -> report error, STOP
|
||||
3. Load issue details:
|
||||
|
||||
```
|
||||
Bash("ccw issue status <issueId> --json")
|
||||
```
|
||||
|
||||
4. Parse JSON response for issue metadata (title, context, priority, labels, feedback)
|
||||
5. Load wisdom files from `<session>/wisdom/` if available
|
||||
|
||||
## Phase 3: Codebase Exploration & Impact Analysis
|
||||
|
||||
**Complexity assessment determines exploration depth**:
|
||||
|
||||
| Signal | Weight | Keywords |
|
||||
|--------|--------|----------|
|
||||
| Structural change | +2 | refactor, architect, restructure, module, system |
|
||||
| Cross-cutting | +2 | multiple, across, cross |
|
||||
| Integration | +1 | integrate, api, database |
|
||||
| High priority | +1 | priority >= 4 |
|
||||
|
||||
| Score | Complexity | Strategy |
|
||||
|-------|------------|----------|
|
||||
| >= 4 | High | Deep exploration via cli-explore-agent |
|
||||
| 2-3 | Medium | Hybrid: ACE search + selective agent |
|
||||
| 0-1 | Low | Direct ACE search only |
|
||||
|
||||
**Exploration execution**:
|
||||
|
||||
| Complexity | Execution |
|
||||
|------------|-----------|
|
||||
| Low | Direct ACE search: `mcp__ace-tool__search_context(project_root_path, query)` |
|
||||
| Medium/High | Spawn cli-explore-agent: `Task({ subagent_type: "cli-explore-agent", run_in_background: false })` |
|
||||
|
||||
**cli-explore-agent prompt template**:
|
||||
|
||||
```
|
||||
## Issue Context
|
||||
ID: <issueId>
|
||||
Title: <issue.title>
|
||||
Description: <issue.context>
|
||||
Priority: <issue.priority>
|
||||
|
||||
## MANDATORY FIRST STEPS
|
||||
1. Run: ccw tool exec get_modules_by_depth '{}'
|
||||
2. Execute ACE searches based on issue keywords
|
||||
3. Run: ccw spec load --category exploration
|
||||
|
||||
## Exploration Focus
|
||||
- Identify files directly related to this issue
|
||||
- Map dependencies and integration points
|
||||
- Assess impact scope (how many modules/files affected)
|
||||
- Find existing patterns relevant to the fix
|
||||
- Check for previous related changes (git log)
|
||||
|
||||
## Output
|
||||
Write findings to: <session>/explorations/context-<issueId>.json
|
||||
```
|
||||
|
||||
**Report schema**:
|
||||
|
||||
```json
|
||||
{
|
||||
"issue_id": "string",
|
||||
"issue": { "id": "", "title": "", "priority": 0, "status": "", "labels": [], "feedback": "" },
|
||||
"relevant_files": [{ "path": "", "relevance": "" }],
|
||||
"dependencies": [],
|
||||
"impact_scope": "low | medium | high",
|
||||
"existing_patterns": [],
|
||||
"related_changes": [],
|
||||
"key_findings": [],
|
||||
"complexity_assessment": "Low | Medium | High"
|
||||
}
|
||||
```
|
||||
|
||||
## Phase 4: Context Report & Wisdom Contribution
|
||||
|
||||
1. Write context report to `<session>/explorations/context-<issueId>.json`
|
||||
2. If file not found from agent, build minimal report from ACE results
|
||||
3. Update `<session>/wisdom/.msg/meta.json` under `explorer` namespace:
|
||||
- Read existing -> merge `{ "explorer": { issue_id, complexity, impact_scope, file_count } }` -> write back
|
||||
4. Contribute discoveries to `<session>/wisdom/learnings.md` if new patterns found
|
||||
89
.claude/skills/team-issue/role-specs/implementer.md
Normal file
89
.claude/skills/team-issue/role-specs/implementer.md
Normal file
@@ -0,0 +1,89 @@
|
||||
---
|
||||
prefix: BUILD
|
||||
inner_loop: false
|
||||
message_types:
|
||||
success: impl_complete
|
||||
failed: impl_failed
|
||||
error: error
|
||||
---
|
||||
|
||||
# Issue Implementer
|
||||
|
||||
Load solution plan, route to execution backend (Agent/Codex/Gemini), run tests, and commit. Execution method determined by coordinator during task creation. Supports parallel instances for batch mode.
|
||||
|
||||
## Modes
|
||||
|
||||
| Backend | Condition | Method |
|
||||
|---------|-----------|--------|
|
||||
| agent | task_count <= 3 or explicit | `Task({ subagent_type: "code-developer", run_in_background: false })` |
|
||||
| codex | task_count > 3 or explicit | `ccw cli --tool codex --mode write --id issue-<issueId>` |
|
||||
| gemini | explicit | `ccw cli --tool gemini --mode write --id issue-<issueId>` |
|
||||
|
||||
## Phase 2: Load Solution & Resolve Executor
|
||||
|
||||
| Input | Source | Required |
|
||||
|-------|--------|----------|
|
||||
| Issue ID | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
|
||||
| Bound solution | `ccw issue solutions <id> --json` | Yes |
|
||||
| Explorer context | `<session>/explorations/context-<issueId>.json` | No |
|
||||
| Execution method | Task description (`execution_method: Agent|Codex|Gemini|Auto`) | Yes |
|
||||
| Code review | Task description (`code_review: Skip|Gemini Review|Codex Review`) | No |
|
||||
|
||||
1. Extract issue ID from task description
|
||||
2. If no issue ID -> report error, STOP
|
||||
3. Load bound solution: `Bash("ccw issue solutions <issueId> --json")`
|
||||
4. If no bound solution -> report error, STOP
|
||||
5. Load explorer context (if available)
|
||||
6. Resolve execution method (Auto: task_count <= 3 -> agent, else codex)
|
||||
7. Update issue status: `Bash("ccw issue update <issueId> --status in-progress")`
|
||||
|
||||
## Phase 3: Implementation (Multi-Backend Routing)
|
||||
|
||||
**Execution prompt template** (all backends):
|
||||
|
||||
```
|
||||
## Issue
|
||||
ID: <issueId>
|
||||
Title: <solution.bound.title>
|
||||
|
||||
## Solution Plan
|
||||
<solution.bound JSON>
|
||||
|
||||
## Codebase Context (from explorer)
|
||||
Relevant files: <explorerContext.relevant_files>
|
||||
Existing patterns: <explorerContext.existing_patterns>
|
||||
Dependencies: <explorerContext.dependencies>
|
||||
|
||||
## Implementation Requirements
|
||||
1. Follow the solution plan tasks in order
|
||||
2. Write clean, minimal code following existing patterns
|
||||
3. Run tests after each significant change
|
||||
4. Ensure all existing tests still pass
|
||||
5. Do NOT over-engineer
|
||||
|
||||
## Quality Checklist
|
||||
- All solution tasks implemented
|
||||
- No TypeScript/linting errors
|
||||
- Existing tests pass
|
||||
- New tests added where appropriate
|
||||
```
|
||||
|
||||
Route by executor:
|
||||
- **agent**: `Task({ subagent_type: "code-developer", run_in_background: false, prompt: <prompt> })`
|
||||
- **codex**: `Bash("ccw cli -p \"<prompt>\" --tool codex --mode write --id issue-<issueId>")`
|
||||
- **gemini**: `Bash("ccw cli -p \"<prompt>\" --tool gemini --mode write --id issue-<issueId>")`
|
||||
|
||||
On CLI failure, resume: `ccw cli -p "Continue" --resume issue-<issueId> --tool <tool> --mode write`
|
||||
|
||||
## Phase 4: Verify & Commit
|
||||
|
||||
| Check | Method | Pass Criteria |
|
||||
|-------|--------|---------------|
|
||||
| Tests pass | Detect and run test command | No new failures |
|
||||
| Code review | Optional, per task config | Review output logged |
|
||||
|
||||
- Tests pass -> optional code review -> `ccw issue update <issueId> --status resolved` -> report `impl_complete`
|
||||
- Tests fail -> report `impl_failed` with truncated test output
|
||||
|
||||
Update `<session>/wisdom/.msg/meta.json` under `implementer` namespace:
|
||||
- Read existing -> merge `{ "implementer": { issue_id, executor, test_status, review_status } }` -> write back
|
||||
94
.claude/skills/team-issue/role-specs/integrator.md
Normal file
94
.claude/skills/team-issue/role-specs/integrator.md
Normal file
@@ -0,0 +1,94 @@
|
||||
---
|
||||
prefix: MARSHAL
|
||||
inner_loop: false
|
||||
subagents: [issue-queue-agent]
|
||||
message_types:
|
||||
success: queue_ready
|
||||
conflict: conflict_found
|
||||
error: error
|
||||
---
|
||||
|
||||
# Issue Integrator
|
||||
|
||||
Queue orchestration, conflict detection, and execution order optimization. Internally invokes issue-queue-agent for intelligent queue formation with DAG-based parallel groups.
|
||||
|
||||
## Phase 2: Collect Bound Solutions
|
||||
|
||||
| Input | Source | Required |
|
||||
|-------|--------|----------|
|
||||
| Issue IDs | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
|
||||
| Bound solutions | `ccw issue solutions <id> --json` | Yes |
|
||||
| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
|
||||
|
||||
1. Extract issue IDs from task description via regex
|
||||
2. Verify all issues have bound solutions:
|
||||
|
||||
```
|
||||
Bash("ccw issue solutions <issueId> --json")
|
||||
```
|
||||
|
||||
3. Check for unbound issues:
|
||||
|
||||
| Condition | Action |
|
||||
|-----------|--------|
|
||||
| All issues bound | Proceed to Phase 3 |
|
||||
| Any issue unbound | Report error to coordinator, STOP |
|
||||
|
||||
## Phase 3: Queue Formation via issue-queue-agent
|
||||
|
||||
**Agent invocation**:
|
||||
|
||||
```
|
||||
Task({
|
||||
subagent_type: "issue-queue-agent",
|
||||
run_in_background: false,
|
||||
description: "Form queue for <count> issues",
|
||||
prompt: "
|
||||
## Issues to Queue
|
||||
Issue IDs: <issueIds>
|
||||
|
||||
## Bound Solutions
|
||||
<solution list with issue_id, solution_id, task_count>
|
||||
|
||||
## Instructions
|
||||
1. Load all bound solutions from .workflow/issues/solutions/
|
||||
2. Analyze file conflicts between solutions using Gemini CLI
|
||||
3. Determine optimal execution order (DAG-based)
|
||||
4. Produce ordered execution queue
|
||||
|
||||
## Expected Output
|
||||
Write queue to: .workflow/issues/queue/execution-queue.json
|
||||
"
|
||||
})
|
||||
```
|
||||
|
||||
**Parse queue result**:
|
||||
|
||||
```
|
||||
Read(".workflow/issues/queue/execution-queue.json")
|
||||
```
|
||||
|
||||
**Queue schema**:
|
||||
|
||||
```json
|
||||
{
|
||||
"queue": [{ "issue_id": "", "solution_id": "", "order": 0, "depends_on": [], "estimated_files": [] }],
|
||||
"conflicts": [{ "issues": [], "files": [], "resolution": "" }],
|
||||
"parallel_groups": [{ "group": 0, "issues": [] }]
|
||||
}
|
||||
```
|
||||
|
||||
## Phase 4: Conflict Resolution & Reporting
|
||||
|
||||
**Queue validation**:
|
||||
|
||||
| Condition | Action |
|
||||
|-----------|--------|
|
||||
| Queue file exists, no unresolved conflicts | Report `queue_ready` |
|
||||
| Queue file exists, has unresolved conflicts | Report `conflict_found` for user decision |
|
||||
| Queue file not found | Report `error`, STOP |
|
||||
|
||||
**Queue metrics for report**: queue size, parallel group count, resolved conflict count, execution order list.
|
||||
|
||||
Update `<session>/wisdom/.msg/meta.json` under `integrator` namespace:
|
||||
- Read existing -> merge `{ "integrator": { queue_size, parallel_groups, conflict_count } }` -> write back
|
||||
85
.claude/skills/team-issue/role-specs/planner.md
Normal file
85
.claude/skills/team-issue/role-specs/planner.md
Normal file
@@ -0,0 +1,85 @@
|
||||
---
|
||||
prefix: SOLVE
|
||||
inner_loop: false
|
||||
additional_prefixes: [SOLVE-fix]
|
||||
subagents: [issue-plan-agent]
|
||||
message_types:
|
||||
success: solution_ready
|
||||
multi: multi_solution
|
||||
error: error
|
||||
---
|
||||
|
||||
# Issue Planner
|
||||
|
||||
Design solutions and decompose into implementation tasks. Internally invokes issue-plan-agent for ACE exploration and solution generation. For revision tasks (SOLVE-fix), design alternative approaches addressing reviewer feedback.
|
||||
|
||||
## Phase 2: Context Loading
|
||||
|
||||
| Input | Source | Required |
|
||||
|-------|--------|----------|
|
||||
| Issue ID | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
|
||||
| Explorer context | `<session>/explorations/context-<issueId>.json` | No |
|
||||
| Review feedback | Task description (for SOLVE-fix tasks) | No |
|
||||
| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
|
||||
|
||||
1. Extract issue ID from task description via regex: `(?:GH-\d+|ISS-\d{8}-\d{6})`
|
||||
2. If no issue ID found -> report error, STOP
|
||||
3. Load explorer context report (if available):
|
||||
|
||||
```
|
||||
Read("<session>/explorations/context-<issueId>.json")
|
||||
```
|
||||
|
||||
4. Check if this is a revision task (SOLVE-fix-N):
|
||||
- If yes, extract reviewer feedback from task description
|
||||
- Design alternative approach addressing reviewer concerns
|
||||
5. Load wisdom files for accumulated codebase knowledge
|
||||
|
||||
## Phase 3: Solution Generation via issue-plan-agent
|
||||
|
||||
**Agent invocation**:
|
||||
|
||||
```
|
||||
Task({
|
||||
subagent_type: "issue-plan-agent",
|
||||
run_in_background: false,
|
||||
description: "Plan solution for <issueId>",
|
||||
prompt: "
|
||||
issue_ids: [\"<issueId>\"]
|
||||
project_root: \"<projectRoot>\"
|
||||
|
||||
## Explorer Context (pre-gathered)
|
||||
Relevant files: <explorerContext.relevant_files>
|
||||
Key findings: <explorerContext.key_findings>
|
||||
Complexity: <explorerContext.complexity_assessment>
|
||||
|
||||
## Revision Required (if SOLVE-fix)
|
||||
Previous solution was rejected by reviewer. Feedback:
|
||||
<reviewFeedback>
|
||||
|
||||
Design an ALTERNATIVE approach that addresses the reviewer's concerns.
|
||||
"
|
||||
})
|
||||
```
|
||||
|
||||
**Expected agent result**:
|
||||
|
||||
| Field | Description |
|
||||
|-------|-------------|
|
||||
| `bound` | Array of auto-bound solutions: `[{issue_id, solution_id, task_count}]` |
|
||||
| `pending_selection` | Array of multi-solution issues: `[{issue_id, solutions: [...]}]` |
|
||||
|
||||
## Phase 4: Solution Selection & Reporting
|
||||
|
||||
**Outcome routing**:
|
||||
|
||||
| Condition | Message Type | Action |
|
||||
|-----------|-------------|--------|
|
||||
| Single solution auto-bound | `solution_ready` | Report to coordinator |
|
||||
| Multiple solutions pending | `multi_solution` | Report for user selection |
|
||||
| No solution generated | `error` | Report failure to coordinator |
|
||||
|
||||
Write solution summary to `<session>/solutions/solution-<issueId>.json`.
|
||||
|
||||
Update `<session>/wisdom/.msg/meta.json` under `planner` namespace:
|
||||
- Read existing -> merge `{ "planner": { issue_id, solution_id, task_count, is_revision } }` -> write back
|
||||
89
.claude/skills/team-issue/role-specs/reviewer.md
Normal file
89
.claude/skills/team-issue/role-specs/reviewer.md
Normal file
@@ -0,0 +1,89 @@
|
||||
---
|
||||
prefix: AUDIT
|
||||
inner_loop: false
|
||||
message_types:
|
||||
success: approved
|
||||
concerns: concerns
|
||||
rejected: rejected
|
||||
error: error
|
||||
---
|
||||
|
||||
# Issue Reviewer
|
||||
|
||||
Review solution plans for technical feasibility, risk, and completeness. Quality gate role between plan and execute phases. Provides clear verdicts: approved, rejected, or concerns.
|
||||
|
||||
## Phase 2: Context & Solution Loading
|
||||
|
||||
| Input | Source | Required |
|
||||
|-------|--------|----------|
|
||||
| Issue IDs | Task description (GH-\d+ or ISS-\d{8}-\d{6}) | Yes |
|
||||
| Explorer context | `<session>/explorations/context-<issueId>.json` | No |
|
||||
| Bound solution | `ccw issue solutions <id> --json` | Yes |
|
||||
| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
|
||||
|
||||
1. Extract issue IDs from task description via regex
|
||||
2. Load explorer context reports for each issue
|
||||
3. Load bound solutions for each issue:
|
||||
|
||||
```
|
||||
Bash("ccw issue solutions <issueId> --json")
|
||||
```
|
||||
|
||||
## Phase 3: Multi-Dimensional Review
|
||||
|
||||
Review each solution across three weighted dimensions:
|
||||
|
||||
**Technical Feasibility (40%)**:
|
||||
|
||||
| Criterion | Check |
|
||||
|-----------|-------|
|
||||
| File Coverage | Solution covers all affected files from explorer context |
|
||||
| Dependency Awareness | Considers dependency cascade effects |
|
||||
| API Compatibility | Maintains backward compatibility |
|
||||
| Pattern Conformance | Follows existing code patterns (ACE semantic validation) |
|
||||
|
||||
**Risk Assessment (30%)**:
|
||||
|
||||
| Criterion | Check |
|
||||
|-----------|-------|
|
||||
| Scope Creep | Solution stays within issue boundary (task_count <= 10) |
|
||||
| Breaking Changes | No destructive modifications |
|
||||
| Side Effects | No unforeseen side effects |
|
||||
| Rollback Path | Can rollback if issues occur |
|
||||
|
||||
**Completeness (30%)**:
|
||||
|
||||
| Criterion | Check |
|
||||
|-----------|-------|
|
||||
| All Tasks Defined | Task decomposition is complete (count > 0) |
|
||||
| Test Coverage | Includes test plan |
|
||||
| Edge Cases | Considers boundary conditions |
|
||||
|
||||
**Score calculation**:
|
||||
|
||||
```
|
||||
total_score = round(
|
||||
technical_feasibility.score * 0.4 +
|
||||
risk_assessment.score * 0.3 +
|
||||
completeness.score * 0.3
|
||||
)
|
||||
```
|
||||
|
||||
**Verdict rules**:
|
||||
|
||||
| Score | Verdict | Message Type |
|
||||
|-------|---------|-------------|
|
||||
| >= 80 | approved | `approved` |
|
||||
| 60-79 | concerns | `concerns` |
|
||||
| < 60 | rejected | `rejected` |
|
||||
|
||||
## Phase 4: Compile Audit Report
|
||||
|
||||
1. Write audit report to `<session>/audits/audit-report.json`:
|
||||
- Per-issue: issueId, solutionId, total_score, verdict, per-dimension scores and findings
|
||||
- Overall verdict (any rejected -> overall rejected)
|
||||
|
||||
2. Update `<session>/wisdom/.msg/meta.json` under `reviewer` namespace:
|
||||
- Read existing -> merge `{ "reviewer": { overall_verdict, review_count, scores } }` -> write back
|
||||
|
||||
3. For rejected solutions, include specific rejection reasons and actionable feedback for SOLVE-fix task creation
|
||||
@@ -74,20 +74,16 @@ Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log",
|
||||
team: **<session-id>**, // MUST be session ID (e.g., ISS-xxx-date), NOT team name. Extract from Session: field.
|
||||
session_id: <session-id>,
|
||||
from: "coordinator",
|
||||
to: "<recipient>",
|
||||
type: <message-type>,
|
||||
summary: "[coordinator] <summary>",
|
||||
ref: <artifact-path>
|
||||
data: {ref: <artifact-path>}
|
||||
})
|
||||
```
|
||||
|
||||
**CLI fallback** (when MCP unavailable):
|
||||
`to` and `summary` auto-defaulted -- do NOT specify explicitly.
|
||||
|
||||
```
|
||||
Bash("ccw team log --team <session-id> --from coordinator --to <recipient> --type <message-type> --summary \"[coordinator] ...\" --json")
|
||||
```
|
||||
**CLI fallback**: `ccw team log --session-id <session-id> --from coordinator --type <type> --json`
|
||||
|
||||
---
|
||||
|
||||
|
||||
375
.claude/skills/team-issue/roles/coordinator/commands/dispatch.md
Normal file
375
.claude/skills/team-issue/roles/coordinator/commands/dispatch.md
Normal file
@@ -0,0 +1,375 @@
|
||||
# Command: Dispatch
|
||||
|
||||
Create the issue resolution task chain with correct dependencies and structured task descriptions based on selected pipeline mode.
|
||||
|
||||
## Phase 2: Context Loading
|
||||
|
||||
| Input | Source | Required |
|
||||
|-------|--------|----------|
|
||||
| Requirement | From coordinator Phase 1 | Yes |
|
||||
| Session folder | From coordinator Phase 2 | Yes |
|
||||
| Pipeline mode | From session.json mode | Yes |
|
||||
| Issue IDs | From session.json issue_ids | Yes |
|
||||
| Execution method | From session.json execution_method | Yes |
|
||||
| Code review | From session.json code_review | No |
|
||||
|
||||
1. Load requirement, pipeline mode, issue IDs, and execution method from session.json
|
||||
2. Determine task chain from pipeline mode
|
||||
|
||||
## Phase 3: Task Chain Creation
|
||||
|
||||
### Task Description Template
|
||||
|
||||
Every task description uses structured format:
|
||||
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "<TASK-ID>",
|
||||
owner: "<role>",
|
||||
description: "PURPOSE: <what this task achieves> | Success: <completion criteria>
|
||||
TASK:
|
||||
- <step 1>
|
||||
- <step 2>
|
||||
- <step 3>
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issue-id-list>
|
||||
- Upstream artifacts: <artifact-list>
|
||||
EXPECTED: <deliverable path> + <quality criteria>
|
||||
CONSTRAINTS: <scope limits>
|
||||
---
|
||||
InnerLoop: false
|
||||
execution_method: <method>
|
||||
code_review: <setting>",
|
||||
blockedBy: [<dependency-list>],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
### Pipeline Router
|
||||
|
||||
| Mode | Action |
|
||||
|------|--------|
|
||||
| quick | Create 4 tasks (EXPLORE -> SOLVE -> MARSHAL -> BUILD) |
|
||||
| full | Create 5 tasks (EXPLORE -> SOLVE -> AUDIT -> MARSHAL -> BUILD) |
|
||||
| batch | Create N+N+1+1+M tasks (EXPLORE-001..N -> SOLVE-001..N -> AUDIT-001 -> MARSHAL-001 -> BUILD-001..M) |
|
||||
|
||||
---
|
||||
|
||||
### Quick Pipeline
|
||||
|
||||
**EXPLORE-001** (explorer):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "EXPLORE-001",
|
||||
owner: "explorer",
|
||||
description: "PURPOSE: Analyze issue context and map codebase impact | Success: Context report with relevant files and dependencies
|
||||
TASK:
|
||||
- Load issue details via ccw issue status
|
||||
- Explore codebase for relevant files and patterns
|
||||
- Assess complexity and impact scope
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issue-id-list>
|
||||
EXPECTED: <session>/explorations/context-<issueId>.json with relevant files, dependencies, and impact assessment
|
||||
CONSTRAINTS: Exploration and analysis only, no solution design
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: [],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**SOLVE-001** (planner):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "SOLVE-001",
|
||||
owner: "planner",
|
||||
description: "PURPOSE: Design solution and decompose into implementation tasks | Success: Bound solution with task decomposition
|
||||
TASK:
|
||||
- Load explorer context report
|
||||
- Generate solution plan via issue-plan-agent
|
||||
- Bind solution to issue
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issue-id-list>
|
||||
- Upstream artifacts: explorations/context-<issueId>.json
|
||||
EXPECTED: <session>/solutions/solution-<issueId>.json with solution plan and task list
|
||||
CONSTRAINTS: Solution design only, no code implementation
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: ["EXPLORE-001"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**MARSHAL-001** (integrator):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "MARSHAL-001",
|
||||
owner: "integrator",
|
||||
description: "PURPOSE: Form execution queue with conflict detection and ordering | Success: Execution queue file with resolved conflicts
|
||||
TASK:
|
||||
- Verify all issues have bound solutions
|
||||
- Detect file conflicts between solutions
|
||||
- Produce ordered execution queue with DAG-based parallel groups
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issue-id-list>
|
||||
- Upstream artifacts: solutions/solution-<issueId>.json
|
||||
EXPECTED: .workflow/issues/queue/execution-queue.json with queue, conflicts, parallel groups
|
||||
CONSTRAINTS: Queue formation only, no implementation
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: ["SOLVE-001"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**BUILD-001** (implementer):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "BUILD-001",
|
||||
owner: "implementer",
|
||||
description: "PURPOSE: Implement solution plan and verify with tests | Success: Code changes committed, tests pass
|
||||
TASK:
|
||||
- Load bound solution and explorer context
|
||||
- Route to execution backend (Agent/Codex/Gemini)
|
||||
- Run tests and verify implementation
|
||||
- Commit changes
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issue-id-list>
|
||||
- Upstream artifacts: explorations/context-<issueId>.json, solutions/solution-<issueId>.json, queue/execution-queue.json
|
||||
EXPECTED: <session>/builds/ with implementation results, tests passing
|
||||
CONSTRAINTS: Follow solution plan, no scope creep
|
||||
---
|
||||
InnerLoop: false
|
||||
execution_method: <execution_method>
|
||||
code_review: <code_review>",
|
||||
blockedBy: ["MARSHAL-001"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
### Full Pipeline
|
||||
|
||||
Creates 5 tasks. First 2 same as Quick, then AUDIT gate before MARSHAL and BUILD.
|
||||
|
||||
**EXPLORE-001** and **SOLVE-001**: Same as Quick pipeline.
|
||||
|
||||
**AUDIT-001** (reviewer):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "AUDIT-001",
|
||||
owner: "reviewer",
|
||||
description: "PURPOSE: Review solution for technical feasibility, risk, and completeness | Success: Clear verdict (approved/rejected/concerns) with scores
|
||||
TASK:
|
||||
- Load explorer context and bound solution
|
||||
- Score across 3 dimensions: technical feasibility (40%), risk (30%), completeness (30%)
|
||||
- Produce verdict: approved (>=80), concerns (60-79), rejected (<60)
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issue-id-list>
|
||||
- Upstream artifacts: explorations/context-<issueId>.json, solutions/solution-<issueId>.json
|
||||
EXPECTED: <session>/audits/audit-report.json with per-issue scores and overall verdict
|
||||
CONSTRAINTS: Review only, do not modify solutions
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: ["SOLVE-001"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**MARSHAL-001** (integrator): Same as Quick, but `blockedBy: ["AUDIT-001"]`.
|
||||
|
||||
**BUILD-001** (implementer): Same as Quick, `blockedBy: ["MARSHAL-001"]`.
|
||||
|
||||
### Batch Pipeline
|
||||
|
||||
Creates tasks in parallel batches. Issue count = N, BUILD tasks = M (from queue parallel groups).
|
||||
|
||||
**EXPLORE-001..N** (explorer, parallel):
|
||||
|
||||
For each issue in issue_ids, create an EXPLORE task. When N > 1, assign distinct owners for parallel spawn:
|
||||
|
||||
| Issue Count | Owner Assignment |
|
||||
|-------------|-----------------|
|
||||
| N = 1 | owner: "explorer" |
|
||||
| N > 1 | owner: "explorer-1", "explorer-2", ..., "explorer-N" (max 5) |
|
||||
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "EXPLORE-<NNN>",
|
||||
owner: "explorer-<N>",
|
||||
description: "PURPOSE: Analyze issue <issueId> context and map codebase impact | Success: Context report for <issueId>
|
||||
TASK:
|
||||
- Load issue details for <issueId>
|
||||
- Explore codebase for relevant files
|
||||
- Assess complexity and impact scope
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issueId>
|
||||
EXPECTED: <session>/explorations/context-<issueId>.json
|
||||
CONSTRAINTS: Single issue scope, exploration only
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: [],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**SOLVE-001..N** (planner, sequential after all EXPLORE):
|
||||
|
||||
For each issue, create a SOLVE task blocked by all EXPLORE tasks:
|
||||
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "SOLVE-<NNN>",
|
||||
owner: "planner",
|
||||
description: "PURPOSE: Design solution for <issueId> | Success: Bound solution with tasks
|
||||
TASK:
|
||||
- Load explorer context for <issueId>
|
||||
- Generate solution plan
|
||||
- Bind solution
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issueId>
|
||||
- Upstream artifacts: explorations/context-<issueId>.json
|
||||
EXPECTED: <session>/solutions/solution-<issueId>.json
|
||||
CONSTRAINTS: Solution design only
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: ["EXPLORE-001", ..., "EXPLORE-<N>"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**AUDIT-001** (reviewer, batch review):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "AUDIT-001",
|
||||
owner: "reviewer",
|
||||
description: "PURPOSE: Batch review all solutions | Success: Verdict for each solution
|
||||
TASK:
|
||||
- Load all explorer contexts and bound solutions
|
||||
- Score each solution across 3 dimensions
|
||||
- Produce per-issue verdicts and overall verdict
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <all-issue-ids>
|
||||
- Upstream artifacts: explorations/*.json, solutions/*.json
|
||||
EXPECTED: <session>/audits/audit-report.json with batch results
|
||||
CONSTRAINTS: Review only
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: ["SOLVE-001", ..., "SOLVE-<N>"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**MARSHAL-001** (integrator): `blockedBy: ["AUDIT-001"]`.
|
||||
|
||||
**BUILD-001..M** (implementer, DAG parallel):
|
||||
|
||||
After MARSHAL produces execution queue, create M BUILD tasks based on parallel groups. When M > 2, assign distinct owners:
|
||||
|
||||
| Build Count | Owner Assignment |
|
||||
|-------------|-----------------|
|
||||
| M <= 2 | owner: "implementer" |
|
||||
| M > 2 | owner: "implementer-1", ..., "implementer-M" (max 3) |
|
||||
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "BUILD-<NNN>",
|
||||
owner: "implementer-<M>",
|
||||
description: "PURPOSE: Implement solution for <issueId> | Success: Code committed, tests pass
|
||||
TASK:
|
||||
- Load bound solution and explorer context
|
||||
- Execute implementation via <execution_method>
|
||||
- Run tests, commit
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <issueId>
|
||||
- Upstream artifacts: explorations/context-<issueId>.json, solutions/solution-<issueId>.json, queue/execution-queue.json
|
||||
EXPECTED: <session>/builds/ with results
|
||||
CONSTRAINTS: Follow solution plan
|
||||
---
|
||||
InnerLoop: false
|
||||
execution_method: <execution_method>
|
||||
code_review: <code_review>",
|
||||
blockedBy: ["MARSHAL-001"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
> **Note**: In Batch mode, BUILD task count M may not be known at dispatch time (depends on MARSHAL queue output). Create BUILD tasks with placeholder count, or defer BUILD task creation to handleCallback when MARSHAL completes. Coordinator should check for deferred BUILD task creation in monitor.md handleCallback for integrator.
|
||||
|
||||
### Review-Fix Cycle (Full/Batch modes)
|
||||
|
||||
When AUDIT rejects a solution, coordinator creates fix tasks dynamically (NOT at dispatch time):
|
||||
|
||||
**SOLVE-fix-001** (planner, revision):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "SOLVE-fix-001",
|
||||
owner: "planner",
|
||||
description: "PURPOSE: Revise solution addressing reviewer feedback (fix cycle <round>) | Success: Revised solution addressing rejection reasons
|
||||
TASK:
|
||||
- Read reviewer feedback from audit report
|
||||
- Design alternative approach addressing concerns
|
||||
- Re-bind revised solution
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <rejected-issue-ids>
|
||||
- Upstream artifacts: audits/audit-report.json
|
||||
- Reviewer feedback: <rejection-reasons>
|
||||
EXPECTED: <session>/solutions/solution-<issueId>.json (revised)
|
||||
CONSTRAINTS: Address reviewer concerns specifically
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: ["AUDIT-001"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
**AUDIT-002** (reviewer, re-review):
|
||||
```
|
||||
TaskCreate({
|
||||
subject: "AUDIT-002",
|
||||
owner: "reviewer",
|
||||
description: "PURPOSE: Re-review revised solution (fix cycle <round>) | Success: Verdict on revised solution
|
||||
TASK:
|
||||
- Load revised solution
|
||||
- Re-evaluate previously rejected dimensions
|
||||
- Produce updated verdict
|
||||
CONTEXT:
|
||||
- Session: <session-folder>
|
||||
- Issue IDs: <rejected-issue-ids>
|
||||
- Upstream artifacts: solutions/solution-<issueId>.json (revised), audits/audit-report.json
|
||||
EXPECTED: <session>/audits/audit-report.json (updated)
|
||||
CONSTRAINTS: Focus on previously rejected dimensions
|
||||
---
|
||||
InnerLoop: false",
|
||||
blockedBy: ["SOLVE-fix-001"],
|
||||
status: "pending"
|
||||
})
|
||||
```
|
||||
|
||||
These fix tasks are created dynamically by handleCallback in monitor.md when reviewer reports rejection, NOT during initial dispatch.
|
||||
|
||||
## Phase 4: Validation
|
||||
|
||||
1. Verify all tasks created with `TaskList()`
|
||||
2. Check dependency chain integrity:
|
||||
- No circular dependencies
|
||||
- All blockedBy references exist
|
||||
- First task(s) have empty blockedBy (EXPLORE tasks)
|
||||
3. Log task count and pipeline mode
|
||||
4. Verify mode-specific constraints:
|
||||
|
||||
| Mode | Constraint |
|
||||
|------|-----------|
|
||||
| quick | Exactly 4 tasks, no AUDIT |
|
||||
| full | Exactly 5 tasks, includes AUDIT |
|
||||
| batch | N EXPLORE + N SOLVE + 1 AUDIT + 1 MARSHAL + M BUILD |
|
||||
202
.claude/skills/team-issue/roles/coordinator/commands/monitor.md
Normal file
202
.claude/skills/team-issue/roles/coordinator/commands/monitor.md
Normal file
@@ -0,0 +1,202 @@
|
||||
# Command: Monitor
|
||||
|
||||
Handle all coordinator monitoring events: worker callbacks, status checks, pipeline advancement, review-fix cycle control, and completion.
|
||||
|
||||
## Constants
|
||||
|
||||
| Key | Value |
|
||||
|-----|-------|
|
||||
| SPAWN_MODE | background |
|
||||
| ONE_STEP_PER_INVOCATION | true |
|
||||
| WORKER_AGENT | team-worker |
|
||||
| MAX_FIX_CYCLES | 2 |
|
||||
|
||||
## Phase 2: Context Loading
|
||||
|
||||
| Input | Source | Required |
|
||||
|-------|--------|----------|
|
||||
| Session state | <session>/session.json (.msg/meta.json) | Yes |
|
||||
| Task list | TaskList() | Yes |
|
||||
| Trigger event | From Entry Router detection | Yes |
|
||||
| Meta state | <session>/.msg/meta.json | Yes |
|
||||
|
||||
1. Load session.json for current state, pipeline mode, fix_cycles
|
||||
2. Run TaskList() to get current task statuses
|
||||
3. Identify trigger event type from Entry Router
|
||||
|
||||
## Phase 3: Event Handlers
|
||||
|
||||
### handleCallback
|
||||
|
||||
Triggered when a worker sends completion message.
|
||||
|
||||
1. Parse message to identify role and task ID:
|
||||
|
||||
| Message Pattern | Role Detection |
|
||||
|----------------|---------------|
|
||||
| `[explorer]` or task ID `EXPLORE-*` | explorer |
|
||||
| `[planner]` or task ID `SOLVE-*` | planner |
|
||||
| `[reviewer]` or task ID `AUDIT-*` | reviewer |
|
||||
| `[integrator]` or task ID `MARSHAL-*` | integrator |
|
||||
| `[implementer]` or task ID `BUILD-*` | implementer |
|
||||
|
||||
2. Mark task as completed:
|
||||
|
||||
```
|
||||
TaskUpdate({ taskId: "<task-id>", status: "completed" })
|
||||
```
|
||||
|
||||
3. Record completion in session state
|
||||
|
||||
4. **Review gate check** (when reviewer completes):
|
||||
- If completed task is AUDIT-* AND pipeline is full or batch:
|
||||
- Read audit report from `<session>/audits/audit-report.json`
|
||||
- Read .msg/meta.json for fix_cycles
|
||||
|
||||
| Verdict | fix_cycles < max | Action |
|
||||
|---------|-----------------|--------|
|
||||
| rejected | Yes | Increment fix_cycles, create SOLVE-fix + AUDIT re-review tasks (see dispatch.md Review-Fix Cycle), proceed to handleSpawnNext |
|
||||
| rejected | No (>= max) | Force proceed -- log warning, unblock MARSHAL |
|
||||
| concerns | - | Log concerns, proceed to MARSHAL (non-blocking) |
|
||||
| approved | - | Proceed to MARSHAL via handleSpawnNext |
|
||||
|
||||
- Log team_msg with type "review_result" or "fix_required"
|
||||
- If force proceeding past rejection, mark skipped fix tasks as completed (skip)
|
||||
|
||||
5. **Deferred BUILD task creation** (when integrator completes):
|
||||
- If completed task is MARSHAL-* AND pipeline is batch:
|
||||
- Read execution queue from `.workflow/issues/queue/execution-queue.json`
|
||||
- Parse parallel_groups to determine BUILD task count M
|
||||
- Create BUILD-001..M tasks dynamically (see dispatch.md Batch Pipeline BUILD section)
|
||||
- Proceed to handleSpawnNext
|
||||
|
||||
6. Proceed to handleSpawnNext
|
||||
|
||||
### handleSpawnNext
|
||||
|
||||
Find and spawn the next ready tasks.
|
||||
|
||||
1. Scan task list for tasks where:
|
||||
- Status is "pending"
|
||||
- All blockedBy tasks have status "completed"
|
||||
|
||||
2. For each ready task, spawn team-worker:
|
||||
|
||||
```
|
||||
Task({
|
||||
subagent_type: "team-worker",
|
||||
description: "Spawn <role> worker for <task-id>",
|
||||
team_name: "issue",
|
||||
name: "<role>",
|
||||
run_in_background: true,
|
||||
prompt: `## Role Assignment
|
||||
role: <role>
|
||||
role_spec: .claude/skills/team-issue/role-specs/<role>.md
|
||||
session: <session-folder>
|
||||
session_id: <session-id>
|
||||
team_name: issue
|
||||
requirement: <task-description>
|
||||
inner_loop: false
|
||||
|
||||
Read role_spec file to load Phase 2-4 domain instructions.
|
||||
Execute built-in Phase 1 -> role-spec Phase 2-4 -> built-in Phase 5.`
|
||||
})
|
||||
```
|
||||
|
||||
3. **Parallel spawn rules**:
|
||||
|
||||
| Pipeline | Scenario | Spawn Behavior |
|
||||
|----------|----------|---------------|
|
||||
| Quick | All stages | One worker at a time |
|
||||
| Full | All stages | One worker at a time |
|
||||
| Batch | EXPLORE-001..N unblocked | Spawn up to 5 explorer workers in parallel |
|
||||
| Batch | BUILD-001..M unblocked | Spawn up to 3 implementer workers in parallel |
|
||||
| Batch | Other stages | One worker at a time |
|
||||
|
||||
4. **Parallel spawn** (Batch mode with multiple ready tasks for same role):
|
||||
|
||||
```
|
||||
Task({
|
||||
subagent_type: "team-worker",
|
||||
description: "Spawn <role>-<N> worker for <task-id>",
|
||||
team_name: "issue",
|
||||
name: "<role>-<N>",
|
||||
run_in_background: true,
|
||||
prompt: `## Role Assignment
|
||||
role: <role>
|
||||
role_spec: .claude/skills/team-issue/role-specs/<role>.md
|
||||
session: <session-folder>
|
||||
session_id: <session-id>
|
||||
team_name: issue
|
||||
requirement: <task-description>
|
||||
inner_loop: false
|
||||
|
||||
Agent name: <role>-<N>
|
||||
Only process tasks where owner === "<role>-<N>".
|
||||
|
||||
Read role_spec file to load Phase 2-4 domain instructions.
|
||||
Execute built-in Phase 1 -> role-spec Phase 2-4 -> built-in Phase 5.`
|
||||
})
|
||||
```
|
||||
|
||||
5. STOP after spawning -- wait for next callback
|
||||
|
||||
### handleCheck
|
||||
|
||||
Output current pipeline status. Do NOT advance pipeline.
|
||||
|
||||
```
|
||||
Pipeline Status (<pipeline-mode>):
|
||||
[DONE] EXPLORE-001 (explorer) -> explorations/context-<id>.json
|
||||
[DONE] SOLVE-001 (planner) -> solutions/solution-<id>.json
|
||||
[RUN] AUDIT-001 (reviewer) -> reviewing...
|
||||
[WAIT] MARSHAL-001 (integrator) -> blocked by AUDIT-001
|
||||
[WAIT] BUILD-001 (implementer) -> blocked by MARSHAL-001
|
||||
|
||||
Fix Cycles: <fix_cycles>/<max_fix_cycles>
|
||||
Mode: <pipeline-mode>
|
||||
Session: <session-id>
|
||||
Issues: <issue-id-list>
|
||||
```
|
||||
|
||||
### handleResume
|
||||
|
||||
Resume pipeline after user pause or interruption.
|
||||
|
||||
1. Audit task list for inconsistencies:
|
||||
- Tasks stuck in "in_progress" -> reset to "pending"
|
||||
- Tasks with completed blockers but still "pending" -> include in spawn list
|
||||
2. Proceed to handleSpawnNext
|
||||
|
||||
### handleComplete
|
||||
|
||||
Triggered when all pipeline tasks are completed.
|
||||
|
||||
**Completion check by mode**:
|
||||
|
||||
| Mode | Completion Condition |
|
||||
|------|---------------------|
|
||||
| quick | All 4 tasks completed |
|
||||
| full | All 5 tasks (+ any fix cycle tasks) completed |
|
||||
| batch | All N EXPLORE + N SOLVE + 1 AUDIT + 1 MARSHAL + M BUILD (+ any fix cycle tasks) completed |
|
||||
|
||||
1. Verify all tasks completed via TaskList()
|
||||
2. If any tasks not completed, return to handleSpawnNext
|
||||
3. If all completed, transition to coordinator Phase 5 (Report + Completion Action)
|
||||
|
||||
**Stall detection** (no ready tasks and no running tasks but pipeline not complete):
|
||||
|
||||
| Check | Condition | Resolution |
|
||||
|-------|-----------|------------|
|
||||
| Worker no response | in_progress task with no callback | Report waiting task list, suggest user `resume` |
|
||||
| Pipeline deadlock | no ready + no running + has pending | Check blockedBy chain, report blocking point |
|
||||
| Fix cycle exceeded | AUDIT rejection > 2 rounds | Terminate loop, force proceed with current solution |
|
||||
|
||||
## Phase 4: State Persistence
|
||||
|
||||
After every handler execution:
|
||||
|
||||
1. Update session.json (.msg/meta.json) with current state (fix_cycles, last event, active tasks)
|
||||
2. Update .msg/meta.json fix_cycles if changed
|
||||
3. Verify task list consistency
|
||||
4. STOP and wait for next event
|
||||
277
.claude/skills/team-issue/roles/coordinator/role.md
Normal file
277
.claude/skills/team-issue/roles/coordinator/role.md
Normal file
@@ -0,0 +1,277 @@
|
||||
# Coordinator - Issue Resolution Team
|
||||
|
||||
**Role**: coordinator
|
||||
**Type**: Orchestrator
|
||||
**Team**: issue
|
||||
|
||||
Orchestrates the issue resolution pipeline: manages task chains, spawns team-worker agents, handles review-fix cycles, and drives the pipeline to completion. Supports quick, full, and batch modes.
|
||||
|
||||
## Boundaries
|
||||
|
||||
### MUST
|
||||
|
||||
- Use `team-worker` agent type for all worker spawns (NOT `general-purpose`)
|
||||
- Follow Command Execution Protocol for dispatch and monitor commands
|
||||
- Respect pipeline stage dependencies (blockedBy)
|
||||
- Stop after spawning workers -- wait for callbacks
|
||||
- Handle review-fix cycles with max 2 iterations
|
||||
- Execute completion action in Phase 5
|
||||
|
||||
### MUST NOT
|
||||
|
||||
- Implement domain logic (exploring, planning, reviewing, implementing) -- workers handle this
|
||||
- Spawn workers without creating tasks first
|
||||
- Skip review gate in full/batch modes
|
||||
- Force-advance pipeline past failed review
|
||||
- Modify source code directly -- delegate to implementer worker
|
||||
- Call implementation subagents directly (issue-plan-agent, issue-queue-agent, code-developer)
|
||||
|
||||
---
|
||||
|
||||
## Command Execution Protocol
|
||||
|
||||
When coordinator needs to execute a command (dispatch, monitor):
|
||||
|
||||
1. **Read the command file**: `roles/coordinator/commands/<command-name>.md`
|
||||
2. **Follow the workflow** defined in the command file (Phase 2-4 structure)
|
||||
3. **Commands are inline execution guides** -- NOT separate agents or subprocesses
|
||||
4. **Execute synchronously** -- complete the command workflow before proceeding
|
||||
|
||||
Example:
|
||||
```
|
||||
Phase 3 needs task dispatch
|
||||
-> Read roles/coordinator/commands/dispatch.md
|
||||
-> Execute Phase 2 (Context Loading)
|
||||
-> Execute Phase 3 (Task Chain Creation)
|
||||
-> Execute Phase 4 (Validation)
|
||||
-> Continue to Phase 4
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Entry Router
|
||||
|
||||
When coordinator is invoked, detect invocation type:
|
||||
|
||||
| Detection | Condition | Handler |
|
||||
|-----------|-----------|---------|
|
||||
| Worker callback | Message contains role tag [explorer], [planner], [reviewer], [integrator], [implementer] | -> handleCallback |
|
||||
| Status check | Arguments contain "check" or "status" | -> handleCheck |
|
||||
| Manual resume | Arguments contain "resume" or "continue" | -> handleResume |
|
||||
| Pipeline complete | All tasks have status "completed" | -> handleComplete |
|
||||
| Interrupted session | Active/paused session exists | -> Phase 0 (Resume Check) |
|
||||
| New session | None of above | -> Phase 1 (Requirement Clarification) |
|
||||
|
||||
For callback/check/resume/complete: load `commands/monitor.md` and execute matched handler, then STOP.
|
||||
|
||||
### Router Implementation
|
||||
|
||||
1. **Load session context** (if exists):
|
||||
- Scan `.workflow/.team-plan/issue/.msg/meta.json` for active/paused sessions
|
||||
- If found, extract session folder path, status, and mode
|
||||
|
||||
2. **Parse $ARGUMENTS** for detection keywords:
|
||||
- Check for role name tags in message content
|
||||
- Check for "check", "status", "resume", "continue" keywords
|
||||
|
||||
3. **Route to handler**:
|
||||
- For monitor handlers: Read `commands/monitor.md`, execute matched handler, STOP
|
||||
- For Phase 0: Execute Session Resume Check below
|
||||
- For Phase 1: Execute Requirement Clarification below
|
||||
|
||||
---
|
||||
|
||||
## Phase 0: Session Resume Check
|
||||
|
||||
Triggered when an active/paused session is detected on coordinator entry.
|
||||
|
||||
1. Load session state from `.workflow/.team-plan/issue/.msg/meta.json`
|
||||
2. Audit task list:
|
||||
|
||||
```
|
||||
TaskList()
|
||||
```
|
||||
|
||||
3. Reconcile session state vs task status:
|
||||
|
||||
| Task Status | Session Expects | Action |
|
||||
|-------------|----------------|--------|
|
||||
| in_progress | Should be running | Reset to pending (worker was interrupted) |
|
||||
| completed | Already tracked | Skip |
|
||||
| pending + unblocked | Ready to run | Include in spawn list |
|
||||
|
||||
4. Rebuild team if not active:
|
||||
|
||||
```
|
||||
TeamCreate({ team_name: "issue" })
|
||||
```
|
||||
|
||||
5. Spawn workers for ready tasks -> Phase 4 coordination loop
|
||||
|
||||
---
|
||||
|
||||
## Phase 1: Requirement Clarification
|
||||
|
||||
1. Parse user task description from $ARGUMENTS
|
||||
2. **Parse arguments** for issue IDs and mode:
|
||||
|
||||
| Pattern | Extraction |
|
||||
|---------|------------|
|
||||
| `GH-\d+` | GitHub issue ID |
|
||||
| `ISS-\d{8}-\d{6}` | Local issue ID |
|
||||
| `--mode=<mode>` | Explicit mode |
|
||||
| `--all-pending` | Load all pending issues |
|
||||
|
||||
3. **Load pending issues** if `--all-pending`:
|
||||
|
||||
```
|
||||
Bash("ccw issue list --status registered,pending --json")
|
||||
```
|
||||
|
||||
4. **Ask for missing parameters** via AskUserQuestion if no issue IDs found
|
||||
|
||||
5. **Mode auto-detection** (when user does not specify `--mode`):
|
||||
|
||||
| Condition | Mode |
|
||||
|-----------|------|
|
||||
| Issue count <= 2 AND no high-priority (priority < 4) | `quick` |
|
||||
| Issue count <= 2 AND has high-priority (priority >= 4) | `full` |
|
||||
| Issue count >= 5 | `batch` |
|
||||
| 3-4 issues | `full` |
|
||||
|
||||
6. **Execution method selection** (for BUILD phase):
|
||||
|
||||
| Option | Description |
|
||||
|--------|-------------|
|
||||
| `Agent` | code-developer agent (sync, for simple tasks) |
|
||||
| `Codex` | Codex CLI (background, for complex tasks) |
|
||||
| `Gemini` | Gemini CLI (background, for analysis tasks) |
|
||||
| `Auto` | Auto-select based on solution task_count (default) |
|
||||
|
||||
7. Record requirement with scope, mode, execution_method, code_review settings
|
||||
|
||||
---
|
||||
|
||||
## Phase 2: Session & Team Setup
|
||||
|
||||
1. Create session directory:
|
||||
|
||||
```
|
||||
Bash("mkdir -p .workflow/.team-plan/issue/explorations .workflow/.team-plan/issue/solutions .workflow/.team-plan/issue/audits .workflow/.team-plan/issue/queue .workflow/.team-plan/issue/builds .workflow/.team-plan/issue/wisdom")
|
||||
```
|
||||
|
||||
2. Write session state to `.msg/meta.json`:
|
||||
|
||||
```json
|
||||
{
|
||||
"session_id": "<session-id>",
|
||||
"status": "active",
|
||||
"team_name": "issue",
|
||||
"mode": "<quick|full|batch>",
|
||||
"issue_ids": [],
|
||||
"requirement": "<requirement>",
|
||||
"execution_method": "<method>",
|
||||
"code_review": "<setting>",
|
||||
"timestamp": "<ISO-8601>",
|
||||
"fix_cycles": {}
|
||||
}
|
||||
```
|
||||
|
||||
3. Initialize wisdom directory (learnings.md, decisions.md, conventions.md, issues.md)
|
||||
|
||||
4. Create team:
|
||||
|
||||
```
|
||||
TeamCreate({ team_name: "issue" })
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Phase 3: Task Chain Creation
|
||||
|
||||
Execute `commands/dispatch.md` inline (Command Execution Protocol):
|
||||
|
||||
1. Read `roles/coordinator/commands/dispatch.md`
|
||||
2. Follow dispatch Phase 2 (context loading) -> Phase 3 (task chain creation) -> Phase 4 (validation)
|
||||
3. Result: all pipeline tasks created with correct blockedBy dependencies
|
||||
|
||||
---
|
||||
|
||||
## Phase 4: Spawn & Coordination Loop
|
||||
|
||||
### Initial Spawn
|
||||
|
||||
Find first unblocked task and spawn its worker:
|
||||
|
||||
```
|
||||
Task({
|
||||
subagent_type: "team-worker",
|
||||
description: "Spawn explorer worker",
|
||||
team_name: "issue",
|
||||
name: "explorer",
|
||||
run_in_background: true,
|
||||
prompt: `## Role Assignment
|
||||
role: explorer
|
||||
role_spec: .claude/skills/team-issue/role-specs/explorer.md
|
||||
session: <session-folder>
|
||||
session_id: <session-id>
|
||||
team_name: issue
|
||||
requirement: <requirement>
|
||||
inner_loop: false
|
||||
|
||||
Read role_spec file to load Phase 2-4 domain instructions.
|
||||
Execute built-in Phase 1 -> role-spec Phase 2-4 -> built-in Phase 5.`
|
||||
})
|
||||
```
|
||||
|
||||
**STOP** after spawning. Wait for worker callback.
|
||||
|
||||
### Coordination (via monitor.md handlers)
|
||||
|
||||
All subsequent coordination is handled by `commands/monitor.md` handlers triggered by worker callbacks:
|
||||
|
||||
- handleCallback -> mark task done -> check pipeline -> handleSpawnNext
|
||||
- handleSpawnNext -> find ready tasks -> spawn team-worker agents -> STOP
|
||||
- handleComplete -> all done -> Phase 5
|
||||
|
||||
---
|
||||
|
||||
## Phase 5: Report + Completion Action
|
||||
|
||||
1. Load session state -> count completed tasks, calculate duration
|
||||
2. List deliverables:
|
||||
|
||||
| Deliverable | Path |
|
||||
|-------------|------|
|
||||
| Context Reports | <session>/explorations/context-*.json |
|
||||
| Solution Plans | <session>/solutions/solution-*.json |
|
||||
| Audit Reports | <session>/audits/audit-report.json |
|
||||
| Execution Queue | .workflow/issues/queue/execution-queue.json |
|
||||
| Build Results | <session>/builds/ |
|
||||
|
||||
3. Output pipeline summary: task count, duration, issues resolved
|
||||
|
||||
4. **Completion Action** (interactive):
|
||||
|
||||
```
|
||||
AskUserQuestion({
|
||||
questions: [{
|
||||
question: "Team pipeline complete. What would you like to do?",
|
||||
header: "Completion",
|
||||
multiSelect: false,
|
||||
options: [
|
||||
{ label: "Archive & Clean (Recommended)", description: "Archive session, clean up tasks and team resources" },
|
||||
{ label: "Keep Active", description: "Keep session active for follow-up work" },
|
||||
{ label: "New Batch", description: "Return to Phase 1 with new issue IDs" }
|
||||
]
|
||||
}]
|
||||
})
|
||||
```
|
||||
|
||||
5. Handle user choice:
|
||||
|
||||
| Choice | Steps |
|
||||
|--------|-------|
|
||||
| Archive & Clean | TaskList -> verify all completed -> update session status="completed" -> TeamDelete("issue") -> output final summary |
|
||||
| Keep Active | Update session status="paused" -> output: "Session paused. Resume with: Skill(skill='team-issue', args='resume')" |
|
||||
| New Batch | Return to Phase 1 |
|
||||
@@ -63,19 +63,17 @@ Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log",
|
||||
team: **<session-id>**, // MUST be session ID (e.g., ISS-xxx-date), NOT team name. Extract from Session: field.
|
||||
session_id: <session-id>,
|
||||
from: "explorer",
|
||||
to: "coordinator",
|
||||
type: <message-type>,
|
||||
summary: "[explorer] <task-prefix> complete: <task-subject>",
|
||||
ref: <artifact-path>
|
||||
data: {ref: <artifact-path>}
|
||||
})
|
||||
```
|
||||
|
||||
**CLI fallback** (when MCP unavailable):
|
||||
|
||||
```
|
||||
Bash("ccw team log --team <session-id> --from explorer --to coordinator --type <message-type> --summary \"[explorer] ...\" --ref <artifact-path> --json")
|
||||
Bash("ccw team log --session-id <session-id> --from explorer --type <message-type> --json")
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
@@ -72,19 +72,17 @@ Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log",
|
||||
team: **<session-id>**, // MUST be session ID (e.g., ISS-xxx-date), NOT team name. Extract from Session: field.
|
||||
session_id: <session-id>,
|
||||
from: "implementer",
|
||||
to: "coordinator",
|
||||
type: <message-type>,
|
||||
summary: "[implementer] <task-prefix> complete: <task-subject>",
|
||||
ref: <artifact-path>
|
||||
data: {ref: <artifact-path>}
|
||||
})
|
||||
```
|
||||
|
||||
**CLI fallback** (when MCP unavailable):
|
||||
|
||||
```
|
||||
Bash("ccw team log --team <session-id> --from implementer --to coordinator --type <message-type> --summary \"[implementer] ...\" --ref <artifact-path> --json")
|
||||
Bash("ccw team log --session-id <session-id> --from implementer --type <message-type> --json")
|
||||
```
|
||||
|
||||
---
|
||||
@@ -264,15 +262,13 @@ Bash("<testCmd> 2>&1 || echo \"TEST_FAILED\"")
|
||||
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log", team: **<session-id>**, from: "implementer", to: "coordinator", // MUST be session ID, NOT team name
|
||||
operation: "log", session_id: <session-id>, from: "implementer",
|
||||
type: "impl_failed",
|
||||
summary: "[implementer] Tests failing for <issueId> after implementation (via <executor>)"
|
||||
})
|
||||
|
||||
SendMessage({
|
||||
type: "message", recipient: "coordinator",
|
||||
content: "## [implementer] Implementation Failed\n\n**Issue**: <issueId>\n**Executor**: <executor>\n**Status**: Tests failing\n**Test Output** (truncated):\n<truncated output>\n\n**Action**: May need solution revision or manual intervention.",
|
||||
summary: "[implementer] impl_failed: <issueId> (<executor>)"
|
||||
})
|
||||
```
|
||||
|
||||
|
||||
@@ -62,19 +62,17 @@ Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log",
|
||||
team: **<session-id>**, // MUST be session ID (e.g., ISS-xxx-date), NOT team name. Extract from Session: field.
|
||||
session_id: <session-id>,
|
||||
from: "integrator",
|
||||
to: "coordinator",
|
||||
type: <message-type>,
|
||||
summary: "[integrator] <task-prefix> complete: <task-subject>",
|
||||
ref: <artifact-path>
|
||||
data: {ref: <artifact-path>}
|
||||
})
|
||||
```
|
||||
|
||||
**CLI fallback** (when MCP unavailable):
|
||||
|
||||
```
|
||||
Bash("ccw team log --team <session-id> --from integrator --to coordinator --type <message-type> --summary \"[integrator] ...\" --ref <artifact-path> --json")
|
||||
Bash("ccw team log --session-id <session-id> --from integrator --type <message-type> --json")
|
||||
```
|
||||
|
||||
---
|
||||
@@ -116,15 +114,13 @@ Bash("ccw issue solutions <issueId> --json")
|
||||
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log", team: **<session-id>**, from: "integrator", to: "coordinator", // MUST be session ID, NOT team name
|
||||
operation: "log", session_id: <session-id>, from: "integrator",
|
||||
type: "error",
|
||||
summary: "[integrator] Unbound issues: <issueIds> - cannot form queue"
|
||||
})
|
||||
|
||||
SendMessage({
|
||||
type: "message", recipient: "coordinator",
|
||||
content: "## [integrator] Error: Unbound Issues\n\nThe following issues have no bound solution:\n<unbound list>\n\nPlanner must create solutions before queue formation.",
|
||||
summary: "[integrator] error: <count> unbound issues"
|
||||
})
|
||||
```
|
||||
|
||||
@@ -192,15 +188,13 @@ Read(".workflow/issues/queue/execution-queue.json")
|
||||
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log", team: **<session-id>**, from: "integrator", to: "coordinator", // MUST be session ID, NOT team name
|
||||
operation: "log", session_id: <session-id>, from: "integrator",
|
||||
type: "conflict_found",
|
||||
summary: "[integrator] <count> unresolved conflicts in queue"
|
||||
})
|
||||
|
||||
SendMessage({
|
||||
type: "message", recipient: "coordinator",
|
||||
content: "## [integrator] Conflicts Found\n\n**Unresolved Conflicts**: <count>\n\n<conflict details>\n\n**Action Required**: Coordinator should present conflicts to user for resolution, then re-trigger MARSHAL.",
|
||||
summary: "[integrator] conflict_found: <count> conflicts"
|
||||
})
|
||||
```
|
||||
|
||||
|
||||
@@ -62,19 +62,17 @@ Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log",
|
||||
team: **<session-id>**, // MUST be session ID (e.g., ISS-xxx-date), NOT team name. Extract from Session: field.
|
||||
session_id: <session-id>,
|
||||
from: "planner",
|
||||
to: "coordinator",
|
||||
type: <message-type>,
|
||||
summary: "[planner] <task-prefix> complete: <task-subject>",
|
||||
ref: <artifact-path>
|
||||
data: {ref: <artifact-path>}
|
||||
})
|
||||
```
|
||||
|
||||
**CLI fallback** (when MCP unavailable):
|
||||
|
||||
```
|
||||
Bash("ccw team log --team <session-id> --from planner --to coordinator --type <message-type> --summary \"[planner] ...\" --ref <artifact-path> --json")
|
||||
Bash("ccw team log --session-id <session-id> --from planner --type <message-type> --json")
|
||||
```
|
||||
|
||||
---
|
||||
@@ -159,15 +157,13 @@ Design an ALTERNATIVE approach that addresses the reviewer's concerns.
|
||||
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log", team: **<session-id>**, from: "planner", to: "coordinator", // MUST be session ID, NOT team name
|
||||
operation: "log", session_id: <session-id>, from: "planner",
|
||||
type: "solution_ready",
|
||||
summary: "[planner] Solution <solution_id> bound to <issue_id> (<task_count> tasks)"
|
||||
})
|
||||
|
||||
SendMessage({
|
||||
type: "message", recipient: "coordinator",
|
||||
content: "## [planner] Solution Ready\n\n**Issue**: <issue_id>\n**Solution**: <solution_id>\n**Tasks**: <task_count>\n**Status**: Auto-bound (single solution)",
|
||||
summary: "[planner] SOLVE complete: <issue_id>"
|
||||
})
|
||||
```
|
||||
|
||||
@@ -175,15 +171,13 @@ SendMessage({
|
||||
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log", team: **<session-id>**, from: "planner", to: "coordinator", // MUST be session ID, NOT team name
|
||||
operation: "log", session_id: <session-id>, from: "planner",
|
||||
type: "multi_solution",
|
||||
summary: "[planner] <count> solutions for <issue_id>, user selection needed"
|
||||
})
|
||||
|
||||
SendMessage({
|
||||
type: "message", recipient: "coordinator",
|
||||
content: "## [planner] Multiple Solutions\n\n**Issue**: <issue_id>\n**Solutions**: <count> options\n\n### Options\n<solution details>\n\n**Action Required**: Coordinator should present options to user for selection.",
|
||||
summary: "[planner] multi_solution: <issue_id>"
|
||||
})
|
||||
```
|
||||
|
||||
|
||||
@@ -65,19 +65,17 @@ Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
|
||||
```
|
||||
mcp__ccw-tools__team_msg({
|
||||
operation: "log",
|
||||
team: **<session-id>**, // MUST be session ID (e.g., ISS-xxx-date), NOT team name. Extract from Session: field.
|
||||
session_id: <session-id>,
|
||||
from: "reviewer",
|
||||
to: "coordinator",
|
||||
type: <message-type>,
|
||||
summary: "[reviewer] <task-prefix> complete: <task-subject>",
|
||||
ref: <artifact-path>
|
||||
data: {ref: <artifact-path>}
|
||||
})
|
||||
```
|
||||
|
||||
**CLI fallback** (when MCP unavailable):
|
||||
|
||||
```
|
||||
Bash("ccw team log --team <session-id> --from reviewer --to coordinator --type <message-type> --summary \"[reviewer] ...\" --ref <artifact-path> --json")
|
||||
Bash("ccw team log --session-id <session-id> --from reviewer --type <message-type> --json")
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
Reference in New Issue
Block a user