feat: Implement GitLabProvider for issue management using glab CLI

- Add GitLabProvider class for handling issue operations, label management, and MR checks.
- Implement methods for ensuring labels, creating issues, listing issues by label, and transitioning labels.
- Introduce a provider factory to auto-detect GitLab or GitHub based on the repository URL.
- Create project registration tool to validate repositories, create state labels, and log project entries.
- Enhance queue status and session health tools to support new session management features.
- Update task completion and task creation tools to support auto-chaining and improved session handling.
- Refactor task pickup tool to streamline model selection and session management.

docs/ONBOARDING.md

@@ -6,9 +6,9 @@
 |---|---|---|
 | [OpenClaw](https://openclaw.ai) installed | DevClaw is an OpenClaw plugin | `openclaw --version` |
 | Node.js >= 20 | Runtime for plugin | `node --version` |
-| [`glab`](https://gitlab.com/gitlab-org/cli) CLI | GitLab issue/label management | `glab --version` |
-| glab authenticated | Plugin calls glab for every label transition | `glab auth status` |
-| A GitLab repo with issues | The task backlog lives in GitLab | `glab issue list` from your repo |
+| [`glab`](https://gitlab.com/gitlab-org/cli) or [`gh`](https://cli.github.com) CLI | Issue tracker provider (auto-detected from remote) | `glab --version` or `gh --version` |
+| CLI authenticated | Plugin calls glab/gh for every label transition | `glab auth status` or `gh auth status` |
+| A GitLab/GitHub repo with issues | The task backlog lives in the issue tracker | `glab issue list` or `gh issue list` from your repo |
 | An OpenClaw agent with Telegram | The orchestrator agent that will manage projects | Agent defined in `openclaw.json` |
 
 ## Setup steps
@@ -41,8 +41,10 @@ In `openclaw.json`, your orchestrator agent needs access to the DevClaw tools:
         "allow": [
           "task_pickup",
           "task_complete",
+          "task_create",
           "queue_status",
-          "session_health"
+          "session_health",
+          "project_register"
         ]
       }
     }]
@@ -50,79 +52,68 @@ In `openclaw.json`, your orchestrator agent needs access to the DevClaw tools:
 }
 ```
 
-The agent only needs the four DevClaw tools. Session management (`sessions_spawn`, `sessions_send`) is **not needed** — the plugin handles session creation and task dispatch internally via OpenClaw CLI. This eliminates the fragile handoff where agents had to correctly call session tools with the right parameters.
+The agent needs the six DevClaw tools. Session management (`sessions_spawn`, `sessions_send`) is **not needed** — the plugin handles session creation and task dispatch internally via OpenClaw CLI. Workers (DEV/QA sub-agent sessions) also use `task_complete` and `task_create` directly for atomic self-reporting.
 
-### 3. Create GitLab labels
+### 3. Register your project
 
-DevClaw uses these labels as a state machine. Create them once per GitLab project:
+Tell the orchestrator agent to register a new project:
 
-```bash
-cd ~/git/your-project
-glab label create "Planning" --color "#6699cc"
-glab label create "To Do" --color "#428bca"
-glab label create "Doing" --color "#f0ad4e"
-glab label create "To Test" --color "#5bc0de"
-glab label create "Testing" --color "#9b59b6"
-glab label create "Done" --color "#5cb85c"
-glab label create "To Improve" --color "#d9534f"
-glab label create "Refining" --color "#f39c12"
-```
+> "Register project my-project at ~/git/my-project for group -1234567890 with base branch development"
 
-### 4. Register a project
-
-Add your project to `memory/projects.json` in the orchestrator's workspace:
+The agent calls `project_register`, which atomically:
+- Validates the repo and auto-detects GitHub/GitLab from remote
+- Creates all 8 state labels (idempotent)
+- Scaffolds role instruction files (`roles/<project>/dev.md` and `qa.md`)
+- Adds the project entry to `projects.json` with `autoChain: false`
+- Logs the registration event
 
 ```json
 {
   "projects": {
-    "<telegram-group-id>": {
+    "-1234567890": {
       "name": "my-project",
       "repo": "~/git/my-project",
       "groupName": "Dev - My Project",
-      "deployUrl": "https://my-project.example.com",
+      "deployUrl": "",
       "baseBranch": "development",
       "deployBranch": "development",
+      "autoChain": false,
       "dev": {
         "active": false,
         "issueId": null,
         "startTime": null,
         "model": null,
-        "sessions": {
-          "haiku": null,
-          "sonnet": null,
-          "opus": null
-        }
+        "sessions": { "haiku": null, "sonnet": null, "opus": null }
       },
       "qa": {
         "active": false,
         "issueId": null,
         "startTime": null,
         "model": null,
-        "sessions": {
-          "grok": null
-        }
+        "sessions": { "grok": null }
       }
     }
   }
 }
 ```
 
+**Manual fallback:** If you prefer CLI control, you can still create labels manually with `glab label create` and edit `projects.json` directly. See the [Architecture docs](ARCHITECTURE.md) for label names and colors.
+
 **Finding the Telegram group ID:** The group ID is the numeric ID of your Telegram supergroup (a negative number like `-1234567890`). You can find it via the Telegram bot API or from message metadata in OpenClaw logs.
 
-### 5. Add the agent to the Telegram group
+### 4. Add the agent to the Telegram group
 
 Add your orchestrator bot to the Telegram group for the project. The agent will now receive messages from this group and can operate on the linked project.
 
-### 6. Create your first issue
+### 5. Create your first issue
 
 Issues can be created in multiple ways:
-- **Via the agent** — Ask the orchestrator in the Telegram group: "Create an issue for adding a login page"
-- **Via glab CLI** — `cd ~/git/my-project && glab issue create --title "My first task" --label "To Do"`
-- **Via GitLab UI** — Create an issue and add the "To Do" label
+- **Via the agent** — Ask the orchestrator in the Telegram group: "Create an issue for adding a login page" (uses `task_create`)
+- **Via workers** — DEV/QA workers can call `task_create` to file follow-up bugs they discover
+- **Via CLI** — `cd ~/git/my-project && glab issue create --title "My first task" --label "To Do"` (or `gh issue create`)
+- **Via web UI** — Create an issue and add the "To Do" label
 
-The orchestrator agent and worker sessions can all create and update issues via `glab` tool usage.
-
-### 7. Test the pipeline
+### 6. Test the pipeline
 
 Ask the agent in the Telegram group:
 
@@ -136,10 +127,7 @@ The agent calls `task_pickup`, which selects a model, transitions the label to "
 
 ## Adding more projects
 
-Repeat steps 3-5 for each new project:
-1. Create labels in the GitLab repo
-2. Add an entry to `projects.json` with the new Telegram group ID
-3. Add the bot to the new Telegram group
+Tell the agent to register a new project (step 3) and add the bot to the new Telegram group (step 4). That's it — `project_register` handles labels and state setup.
 
 Each project is fully isolated — separate queue, separate workers, separate state.
 
@@ -147,15 +135,18 @@ Each project is fully isolated — separate queue, separate workers, separate st
 
 | Responsibility | Who | Details |
 |---|---|---|
-| GitLab label setup | You (once per project) | 8 labels, created via `glab label create` |
-| Project registration | You (once per project) | Entry in `projects.json` |
+| Label setup | Plugin (`project_register`) | 8 labels, created idempotently via `IssueProvider` |
+| Role file scaffolding | Plugin (`project_register`) | Creates `roles/<project>/dev.md` and `qa.md` from defaults |
+| Project registration | Plugin (`project_register`) | Entry in `projects.json` with empty worker state |
 | Agent definition | You (once) | Agent in `openclaw.json` with tool permissions |
 | Telegram group setup | You (once per project) | Add bot to group |
-| Issue creation | Agent or worker sessions | Created via `glab` tool usage (or manually via GitLab UI) |
-| Label transitions | Plugin | Atomic `--unlabel` + `--label` via glab |
-| Model selection | Plugin | Keyword-based heuristic per task |
+| Issue creation | Plugin (`task_create`) | Orchestrator or workers create issues from chat |
+| Label transitions | Plugin | Atomic label transitions via issue tracker CLI |
+| Model selection | Plugin | LLM-selected by orchestrator, keyword heuristic fallback |
 | State management | Plugin | Atomic read/write to `projects.json` |
 | Session management | Plugin | Creates, reuses, and dispatches to sessions via CLI. Agent never touches session tools. |
+| Task completion | Plugin (`task_complete`) | Workers self-report. Auto-chains if enabled. |
+| Role instructions | Plugin (`task_pickup`) | Loaded from `roles/<project>/<role>.md`, appended to task message |
 | Audit logging | Plugin | Automatic NDJSON append per tool call |
 | Zombie detection | Plugin | `session_health` checks active vs alive |
-| Queue scanning | Plugin | `queue_status` queries GitLab per project |
+| Queue scanning | Plugin | `queue_status` queries issue tracker per project |