git clone - Clone repositories
git fetch / git pull - Fetch/pull from remote
git push - Push to remote
git checkout / git switch - Switch branches
git branch - Manage branches
git add / git commit - Stage and commit
git merge - Merge branches
git rebase - Rebase commits (including interactive)
git cherry-pick - Cherry-pick commits
git reset / git revert - Undo changes
git stash - Stash changes
git tag - Manage tags
git submodule - Manage submodules
And any other git command...

If git can do it, you can delegate it.

When to Use This Skill vs github-operations

Task	Use git-delegation	Use github-operations
Clone repository	✅
Pull/fetch changes	✅
Read/write files	✅
Create/switch branches	✅
Commit/push code	✅
Rebase/cherry-pick	✅
Manage tags	✅
Create PR		✅
Review/merge PR		✅
Comment on PR		✅
Create/update Issue		✅

Message Format

Send a git-request: message to the Manager.

First, get your actual Matrix domain:

echo $HICLAW_MATRIX_DOMAIN
# e.g.: matrix-local.hiclaw.io:18080

Then send (substitute the real domain — do NOT write $HICLAW_MATRIX_DOMAIN literally):

@manager:matrix-local.hiclaw.io:18080 task-{task-id} git-request:
workspace: /root/hiclaw-fs/shared/tasks/{task-id}/workspace/{repo-name}
operations:
  - git clone https://github.com/org/repo.git
  - git checkout -b feature-auth
  - git add .
  - git commit -m "feat: add authentication"
  - git push origin feature-auth
---CONTEXT---
{What you're trying to accomplish}
---END---

Fields:

workspace: Directory to work in (parent dir for clone, repo dir for other ops)
operations: List of git commands to execute (literally what to run)
context: (Optional) What you're trying to accomplish - helps Manager understand intent

Step-by-Step Workflow

1. Check for Processing Marker

Before making changes, check if the task directory is being processed:

# Sync from MinIO
mc mirror "${HICLAW_STORAGE_PREFIX}/shared/tasks/{task-id}/" \
  "/root/hiclaw-fs/shared/tasks/{task-id}/"

# Check for processing marker
if [ -f "/root/hiclaw-fs/shared/tasks/{task-id}/.processing" ]; then
    echo "Task directory is being processed. Wait for manager to complete."
fi

2. Prepare Your Request

Write out the git commands you want executed:

@manager:DOMAIN task-20260225 git-request:
workspace: /root/hiclaw-fs/shared/tasks/task-20260225/workspace
operations:
  - git clone https://github.com/higress-group/hiclaw.git
  - cd hiclaw && git checkout -b feature-xyz
---CONTEXT---
Starting work on feature XYZ
---END---

3. Wait for Response

Success — git-result:

@alice:DOMAIN task-20260225 git-result:
Git operations completed successfully.
Cloned to: /root/hiclaw-fs/shared/tasks/task-20260225/workspace/hiclaw
Created branch: feature-xyz
Run `hiclaw-sync` to sync.

Failure — git-failed:

@alice:DOMAIN task-20260225 git-failed:
Git operation failed: {error message}
{Suggestion for how to fix}

4. Sync and Continue

After receiving git-result::

# Sync from MinIO
hiclaw-sync

# Now you can work locally
cd /root/hiclaw-fs/shared/tasks/task-20260225/workspace/hiclaw

# Read files, modify files, etc.
cat src/main.py
# ... make changes ...

# When ready to commit, sync to MinIO first
mc mirror "/root/hiclaw-fs/shared/tasks/task-20260225/" \
  "${HICLAW_STORAGE_PREFIX}/shared/tasks/task-20260225/" --overwrite

5. Commit and Push

After making local changes:

@manager:DOMAIN task-20260225 git-request:
workspace: /root/hiclaw-fs/shared/tasks/task-20260225/workspace/hiclaw
operations:
  - git add .
  - git commit -m "feat: implement feature XYZ"
  - git push origin feature-xyz
---CONTEXT---
Completed implementation of feature XYZ
---END---

Local vs Delegated Operations

You can run any git command that doesn't need authentication locally:

# These work locally (no auth needed):
git status
git log
git diff
git branch
git diff --staged

# These require delegation (need auth):
git clone https://github.com/...
git push
git fetch
git pull

Advanced Operations

Interactive Rebase

@manager:DOMAIN task-20260225 git-request:
workspace: /root/hiclaw-fs/shared/tasks/task-20260225/workspace/hiclaw
operations:
  - git rebase -i HEAD~3
---CONTEXT---
Squashing the last 3 commits into one
---END---

Cherry-pick

@manager:DOMAIN task-20260225 git-request:
workspace: /root/hiclaw-fs/shared/tasks/task-20260225/workspace/hiclaw
operations:
  - git cherry-pick abc123def
---CONTEXT---
Cherry-picking fix from main branch
---END---

Merge with Strategy

@manager:DOMAIN task-20260225 git-request:
workspace: /root/hiclaw-fs/shared/tasks/task-20260225/workspace/hiclaw
operations:
  - git merge feature-xyz --no-ff -m "Merge feature XYZ"
---CONTEXT---
Merging feature branch with merge commit
---END---

Critical Rules

Plan First, Send Once

Before sending a git-request:, plan ALL operations in your head first. Think through the entire workflow — clone, branch, file creation, commit, push — and include everything in a SINGLE request. Do NOT send partial requests and iterate.

Bad (multiple requests, trial-and-error):

# Request 1: just clone
git-request: clone repo...
# Wait... then Request 2: create branch
git-request: checkout branch...
# Wait... then Request 3: add files and push
git-request: add, commit, push...

Good (one complete request):

git-request:
workspace: /root/hiclaw-fs/shared/tasks/{task-id}/workspace
operations:
  - git clone /path/to/repo.git
  - cd repo && git config user.name "alice"
  - cd repo && git config user.email "alice@hiclaw.local"
  - cd repo && git checkout -b feature/my-branch
  - mkdir -p repo/docs
  - 'cat > repo/docs/file.md << "EOF"
file content here
EOF'
  - cd repo && git add docs/file.md
  - cd repo && git commit -m "feat: add file"
  - cd repo && git push origin feature/my-branch
---CONTEXT---
Complete workflow: clone, branch, create file, commit, push
---END---

Wait Silently After Sending

After sending a git-request:, the Manager needs time to execute the operations. Do NOT:

Send follow-up messages asking "is it done?"
Send duplicate or revised git-request: messages
Try alternative approaches while waiting
Spawn subagents to work around the wait

Simply wait for the git-result: or git-failed: response. The Manager will reply when done.

Workspace Path Convention

Always use this path pattern:

/root/hiclaw-fs/shared/tasks/{task-id}/workspace/{repo-name}

For git clone: set workspace to the parent directory (without repo name)
For all other operations: set workspace to the repo directory (with repo name)
Never use /tmp or other arbitrary paths — the Manager syncs via MinIO and needs the workspace under the shared tasks directory

Include Non-Git Commands When Needed

The operations list can include shell commands like mkdir -p, cat > file, cd dir && prefixes. This lets you do everything in one round-trip:

operations:
  - git clone https://github.com/org/repo.git
  - cd repo && git checkout -b feature/xyz
  - mkdir -p repo/src
  - 'cat > repo/src/main.py << "EOF"
print("hello")
EOF'
  - cd repo && git add .
  - cd repo && git commit -m "feat: add main"
  - cd repo && git push origin feature/xyz

Tips

One request, all commands: Include clone, branch, file creation, commit, and push in a single request
Provide context: Help the Manager understand what you're trying to accomplish
Handle errors: If git-failed: is returned, read the error and send ONE corrected request
Sync before and after: Always sync to/from MinIO when exchanging workspace with Manager
Use github-operations for PRs: After pushing, use the MCP tools to create/manage PRs

git-delegation

Git Delegation

What Can Be Delegated