From coordination
Use during parallel agent work to write coordination signals - structured journal entries for claims, decisions, problems, and completions; prevents merge conflicts and duplicate work between concurrent agents
npx claudepluginhub nice-wolf-studio/wolf-skills-marketplace --plugin coordinationThis skill uses the workspace's default tool permissions.
Write structured coordination signals during active work. Signals are typed journal entries that other agents check at natural breakpoints (before editing claimed files, after making architectural decisions).
Guides Next.js Cache Components and Partial Prerendering (PPR) with cacheComponents enabled. Implements 'use cache', cacheLife(), cacheTag(), revalidateTag(), static/dynamic optimization, and cache debugging.
Guides building MCP servers enabling LLMs to interact with external services via tools. Covers best practices, TypeScript/Node (MCP SDK), Python (FastMCP).
Generates original PNG/PDF visual art via design philosophy manifestos for posters, graphics, and static designs on user request.
Write structured coordination signals during active work. Signals are typed journal entries that other agents check at natural breakpoints (before editing claimed files, after making architectural decisions).
Signals are NOT chat. They are structured, typed messages — four types, one purpose each. An agent should be able to read all active signals in under 200 tokens.
/handoff instead/pickup insteadSignals live in the journal directory of the shared handoff space:
MAIN_WORKTREE=$(git worktree list --porcelain | head -1 | sed 's/worktree //')
HANDOFF_DIR="${MAIN_WORKTREE}/.claude/handoff"
JOURNAL_DIR="${HANDOFF_DIR}/journal/${AGENT_NAME}"
Agent identity follows the same rules as /handoff — worktree name, branch name, or timestamp fallback.
Every signal has a type field. There are exactly four types. Use the right one.
Write a CLAIM when you're about to do significant work on files that other agents might also need. Claims are advisory but respected — the pickup protocol flags conflicts with claims.
---
type: claim
agent: {agent-name}
timestamp: {ISO-8601}
---
Claiming exclusive work on {area/module}.
Files: {file1}, {file2}, {file3}
Reason: {Why concurrent edits would conflict}
Duration: {Expected — e.g., "this session", "next 2 hours"}
When: Before starting work on shared code. Check active claims first — if someone already claims your target files, coordinate before proceeding.
Write a DECISION when you make a choice that constrains future work. Other agents need to know this so they don't make conflicting choices.
---
type: decision
agent: {agent-name}
timestamp: {ISO-8601}
---
Decision: {What you decided}
Rationale: {Why — one sentence}
Affects: {What code/agents this constrains}
When: After making any non-obvious architectural, design, or implementation choice. If reversing your decision would require another agent to redo work, signal it.
Write a PROBLEM when you discover something that crosses into another agent's territory or changes shared assumptions.
---
type: problem
agent: {agent-name}
timestamp: {ISO-8601}
affects: {agent-name or "all"}
---
Problem: {What you found}
Impact: {How it affects the other agent's work}
Suggestion: {Optional — what they should do about it}
When: You find a bug, design flaw, or constraint that another agent needs to know about. Don't signal problems that only affect your own work.
Write a COMPLETE when you finish a significant chunk of work. This releases any claims you had and notifies others that the codebase state has changed in your area.
---
type: complete
agent: {agent-name}
timestamp: {ISO-8601}
---
Completed: {What you finished}
Released: {Files/areas no longer claimed}
Changed assumptions: {What other agents should re-check, if anything}
When: After completing a milestone, merging, or finishing work on claimed files. Always pair with releasing your claims.
Before writing a signal, check existing signals to avoid duplicates or conflicts:
# Read recent signals from all agents
for agent_dir in "${HANDOFF_DIR}/journal/"*/; do
AGENT=$(basename "$agent_dir")
LATEST=$(ls "$agent_dir" 2>/dev/null | sort -n | tail -3)
for f in $LATEST; do
echo "=== ${AGENT}/${f} ==="
cat "${agent_dir}/${f}" 2>/dev/null
done
done
For CLAIM signals: Verify no one else has already claimed the same files. For DECISION signals: Verify no conflicting decision has been made.
Gate: You've read recent signals and confirmed no conflicts.
Determine the next sequence number and write the signal:
LAST=$(ls "${JOURNAL_DIR}/" 2>/dev/null | sort -n | tail -1 | sed 's/\.md//')
NEXT=$(printf "%04d" $(( ${LAST:-0} + 1 )))
Write to ${JOURNAL_DIR}/${NEXT}.md using the appropriate type template above.
Gate: Signal file is written with correct type, frontmatter, and structured content.
If you wrote a CLAIM, update your presence file's touching array to include the claimed files:
# Update presence file with new claims
cat > "${HANDOFF_DIR}/active/${AGENT_NAME}.json" << EOF
{
"agent": "${AGENT_NAME}",
"branch": "$(git branch --show-current)",
"started": "{original-start-time}",
"heartbeat": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
"task": "{current-task}",
"touching": ["{all-claimed-files}"],
"status": "working"
}
EOF
If you wrote a COMPLETE, remove the completed files from your touching array.
Gate: Presence file reflects your current claims.
Agents should check signals at these natural breakpoints:
Quick check command:
# Find signals from the last hour across all agents
find "${HANDOFF_DIR}/journal/" -name "*.md" -newer /tmp/signal-check-marker 2>/dev/null | while read f; do head -8 "$f"; echo "---"; done
touch /tmp/signal-check-marker
Signal and coordinate serve the same purpose — agent coordination — via different transports:
| /signal | /coordinate | |
|---|---|---|
| Transport | Filesystem (project repo) | Git (switchboard repo) |
| Speed | Instant (file read) | Git push/pull cycle |
| Scope | Same machine only | Cross-machine |
| Best for | 2-4 local agents | Distributed teams |
If a switchboard is configured in ~/.claude/coordination.json, prefer /coordinate. Use /signal as the fast path when all agents share a filesystem, or as the fallback when the switchboard is unreachable.
If you catch yourself:
STOP. If it doesn't help another agent make a better decision, it's noise, not signal.
Before considering the signal complete:
/handoff — End-of-work memory transfer. Signals are mid-work; handoffs are post-work./pickup — Reads signals as part of context reconstruction. Your signals are consumed here./repo-ingest — Updates the coordination protocol from external repos.MANDATORY NEXT STEPS:
OPTIONAL NEXT STEPS:
v1.1.0 (2026-04-11)
v1.0.0 (2026-04-11)