@anyi61/codex-claude-delegate-mcp 0.1.0

package/plugins/codex-claude-delegate/skills/claude-delegate.md

@@ -0,0 +1,30 @@
+# Claude Code Delegate
+
+Use `claude_task` for normal read/review/write delegation. After it returns a `job_id`, call `claude_job_wait` for that same job. Respect `recommended_delay_ms` and `next_allowed_poll_at`. If `poll_too_soon=true`, wait until `next_allowed_poll_at` before polling again. Do not start another job or implement locally while `waiting=true`.
+First run sequence: `claude_setup` -> `claude_task` -> `claude_job_wait` -> `claude_result`.
+
+`claude_task` does not accept `max_turns`. If the user explicitly asks for a turn cap, use the appropriate Advanced / Debug tool (`claude_query`, `claude_review`, or `claude_implement`) instead of the default high-level entrypoint.
+
+For write tasks, `claude_task` produces an isolated git worktree result only — it never directly applies changes to the main workspace. Non-preview `claude_apply` modifies the main workspace. Always run `claude_apply preview=true` first, show or summarize the planned diff, and wait for explicit user approval before calling non-preview `claude_apply` with `confirmed_by_user=true`.
+
+`preview=true` and `cleanup=true` must not be combined in a single `claude_apply` call — the server rejects this combination. Workflow `next_actions` from `claude_result` or `claude_job_wait` only suggests `preview=true` actions; it never emits direct non-preview apply suggestions.
+
+For normal `claude_task` calls, do not pass `files`. If Claude should read a plan or checklist, use `instruction_files` or mention the file in `task`; these files are context, not modification scope. Use Advanced / Debug `claude_implement.files` only when strict file modification limits are explicitly required.
+
+## When NOT to use claude_implement
+
+- Single-line bug fixes
+- Adding a simple function to one file
+- Tasks you can complete correctly in < 3 trivial edits
+- Read-only tasks (use `claude_task mode=read` instead)
+
+## Default workflow
+
+1. Start with `claude_task mode=write` and pass `task`, `cwd`, optional `instruction_files`, `constraints`, `max_cost_usd`, `max_changed_files`.
+2. Capture the returned `job_id`.
+3. Poll with `claude_job_wait`, respecting `recommended_delay_ms`.
+4. When the job finishes terminal, call `claude_result`.
+5. Preview with `claude_apply preview=true` (no user approval needed for preview).
+6. Show or summarize the planned diff to the user and ask whether to apply it.
+7. Only after explicit user approval, apply with `claude_apply cleanup=true confirmed_by_user=true`.
+8. Use `claude_cleanup` for leftover delegated worktrees.

package/plugins/codex-claude-delegate/skills/claude-rescue.md

@@ -0,0 +1,52 @@
+# Claude Code Rescue — Failure Recovery
+
+Rescue workflows may use Advanced / Debug tools such as `claude_workspace_status`, `claude_job_result`, `claude_runs`, `claude_run_inspect`, and `claude_job_cancel`. Use them only after the default `claude_job_wait` / `claude_result` path is insufficient or the user explicitly asks for diagnosis.
+
+If an apply was refused because a high-level `claude_task` was given a plan file through deprecated `files`, retry the high-level task with `instruction_files` instead. Strict file scope belongs to Advanced / Debug `claude_implement.files`.
+
+## When to use rescue procedures
+
+Use these steps when `claude_implement` fails or produces unexpected results:
+
+### 1. Implement failed (timeout / max_turns / error)
+
+```
+claude_status  # check if worktree exists
+```
+
+If worktree was created but Claude timed out:
+- Run `claude_query` to inspect the partial worktree state
+- Consider re-running `claude_implement` with a **smaller, more focused task**
+- Use `session_key` if you want Claude to resume (but beware context pollution)
+
+### 2. Changed files exceeded limit
+
+If `server_observed.resource_limits.changed_files_exceeded` is true:
+- The worktree contains more changes than expected
+- Run `claude_review` on the worktree diff before deciding
+- Either apply if changes are correct, or discard the worktree
+
+### 3. Apply conflicts
+
+If `claude_apply` reports conflicts (uncommitted changes in main workspace):
+- Commit or stash your local changes first
+- Then retry `claude_apply`
+- Do NOT force-apply partial changes (the tool refuses to partially apply)
+
+If `claude_apply` reports `No changed source files found`:
+- Confirm the worktree actually changed files under `src/`
+- Remember docs, `dist/`, and root-level files are intentionally ignored
+- Untracked `src/` files should be detected; if not, inspect `git status --short -- src/` inside the worktree
+
+### 4. Stale worktrees
+
+If `claude_status` shows leftover worktrees:
+- Run `claude_cleanup` (dry-run first to see what will be removed)
+- Then `claude_cleanup dry_run: false` to remove them
+- This frees disk space and keeps `git worktree list` clean
+
+## General principles
+
+- **Never apply blindly**: always review Claude's diff via `server_observed` first
+- **Prefer smaller tasks**: a failed 5-file refactor should be split into 3 single-file tasks
+- **Check worktree state**: use `claude_status` before retrying to understand what was left behind

package/plugins/codex-claude-delegate/skills/claude-review.md

@@ -0,0 +1,25 @@
+# Claude Code Review
+
+For ordinary review requests, prefer `claude_task mode=review` and poll with `claude_job_wait`. Use `instruction_files` for plan/checklist context. Use direct `claude_review` only for Advanced / Debug workflows or when the user explicitly asks for the bottom-level tool.
+
+## When to use review
+
+1. **Before risky implementations** — diff of planned changes before applying to main branch
+2. **Complex patches** — diffs that touch multiple modules or cross-cutting concerns
+3. **Security-sensitive changes** — authentication, authorization, input handling, secrets management
+4. **Unfamiliar code** — when you are not sure about edge cases or idiomatic patterns
+5. **After claude_implement** — review Claude's diff before calling `claude_apply`
+
+## How it works
+
+- Claude runs in read-only mode (cannot modify files)
+- Provide a task description and optional diff/file list
+- Returns structured findings, recommendations, and severity (critical/high/medium/low/none)
+
+## When NOT to use claude_review
+
+- Typos or trivial formatting (use linters instead)
+- After you have already applied changes (review before apply)
+- When you just need to understand code (use `claude_query` instead)
+
+A review result is not apply approval. After reviewing a delegated worktree, ask the user before any non-preview `claude_apply` call.