Project Management

Project Management — Autonomous Execution Loop

Work continuously across all Swarm projects. Do not stop to ask permission. Execute the highest-priority item, commit, move to the next. Only stop when:

1. Nothing left to do — all actionable items complete
2. Blocked on operator — needs credentials, physical access, review, or a decision
3. Operator says stop — explicit instruction to halt

Startup (fast — under 60 seconds)

1. Read Last Session Summary

ls -t /opt/swarm/artifacts/summaries/*.yaml | head -1 | xargs cat

This is the source of truth. It tells you what was done, what's blocked, and context_for_next. Do NOT rediscover project state from scratch.

2. Quick Status (parallel)

python3 <coordination-tool-root>/src/swarm_cli.py status
python3 <coordination-tool-root>/src/swarm_cli.py inbox
ls /opt/swarm/tasks/pending/task-*.yaml 2>/dev/null

3. Targeted Checks

Only check repos/services mentioned in context_for_next. Skip everything else.

4. Build Work Queue

Apply Priority Framework. Build an ordered list of actionable items. Separate into two lists:

• ACTIONABLE — can do right now, no blockers
• BLOCKED — needs operator, hardware, credentials, etc.

Start executing immediately. Don't pause to report the queue — the operator will see progress in commits and status lines.

Work Loop

WHILE actionable_items remain:
    1. Pick highest-priority ACTIONABLE item
    2. Execute it (write code, run tests, commit, push)
    3. After completing each item:
       a. Commit with meaningful message
       b. Run tests if applicable
       c. Update the project registry if phase changed
       d. Brief status line to operator (1 sentence)
    4. Re-evaluate: did this unblock anything? Add to queue.
    5. Continue to next item

WHEN all actionable items done OR blocked:
    → Run Session End Protocol
    → Report blocked items to operator

Work Loop Rules

• Commit after every meaningful unit of work. Don't batch up.
• Run tests before moving on from any project that has them.
• Pre-flight batch operations: check target schema first, test on 1 record, verify full pipeline, then scale.
• Verify before editing specs: SSH to the machine (nvidia-smi, lscpu, free -h) before changing hardware claims.
• If a task takes >30 min and you haven't updated the operator, give a brief status line.
• If you hit an unexpected blocker, log it and move to the next item. Don't spin.
• Use subagents for parallel work when items are independent (e.g., tests on while writing code on ).
• Use for speed — SSH to for test execution, heavy builds, anything CPU-bound.
• Never ask "want me to do X?" — if it's non-breaking and moves forward, just do it.

Session End Protocol

Execute when all work is done or all remaining items are blocked.

1. Uncommitted Work Check

for dir in <repo-path>/e <repo-path>/f <repo-path>/g <repo-path>/h \
           <repo-path>/i <repo-path>/j /opt/projects/main <repo-path>/b \
           <coordination-tool-root> <repo-path>/a <repo-path>/c <repo-path>/d \
           <repo-path>/k; do
  if [ -d "$dir/.git" ]; then
    changes=$(git -C "$dir" status --porcelain 2>/dev/null | wc -l)
    if [ "$changes" -gt 0 ]; then
      echo "UNCOMMITTED: $dir ($changes files)"
    fi
  fi
done

Commit everything. Don't leave dirty repos.

2. Generate Session Summary

Write to /opt/swarm/artifacts/summaries/<hostname>-<timestamp>.yaml:

hostname: <hostname>
session_id: <session>
timestamp: <now>
project: <primary project worked on>
duration_minutes: <estimate>
key_decisions:
  - <decision 1>
files_changed:
  - <file 1>
issues_found:
  - <issue if any>
artifacts_produced:
  - <artifact if any>
context_for_next: "<explicit handoff — what to pick up, what's blocked, what changed>"

The context_for_next field is the most important. Be specific.

3. Skill & Config Sync

ALWAYS run — catches skill edits, script changes, hook updates:

cd /opt/claude-configs/claude-config && ./scripts/collect.sh
git -C /opt/claude-configs/claude-config add -A
git -C /opt/claude-configs/claude-config diff --cached --stat
git -C /opt/claude-configs/claude-config commit -m "sync: updates from $(hostname) session" || true
git -C /opt/claude-configs/claude-config push || true

This is NOT optional. Every session end must sync claude-config.

4. Final Report

Tell the operator:

• What was completed
• What's blocked and why
• What the next session should pick up

Priority Framework

Tier 1: Revenue & Active Delivery

Tier 2: Infrastructure & Dependencies

Tier 3: Growth & Future

Tiebreaker Rules

1. Revenue potential breaks ties between same-tier items.
2. "What unblocks the most?" breaks ties between infrastructure items.
3. Resource fit: GPU work only when is available; CPU/web work anytime on .
4. Quick wins (<30 min) get a +1 tier bump if they close out a phase.
5. Security hardening before feature work, always.

Decision Trees

" is offline"

Available on <primary-host> alone:
- <internal-project-1> maintenance (fullnode, P2Pool, monitoring)
- <your-project> development (CPU-only)
- Audit Sentinel development (SQLite, no GPU needed)
- ClauseHound development (CPU-only)
- Prompt Forge development (CPU-only)
- hydra-swarm development
- Fleet hardening (Ansible roles)
- Documentation, planning, PRDs

Available on <worker-host> (if <gpu-host> down):
- Ollama inference via phi4:14b or qwen3:8b (RTX 5060 Ti)
- ComfyUI workflows (http://<worker-host-ip>:<comfyui-port>)
- <your-project> QA review (phi4 on <worker-host> Ollama)

NOT available without <gpu-host>:
- <internal-project-2> (needs ChromaDB + Ollama on <gpu-host>)
- AI Server stack management (Swarm manager)
- Docker Swarm control plane operations
- Milvus-dependent <internal-project-4> work

"Project at phase boundary"

1. Run verification for current phase (tests, health checks).
2. Update project registry (phase field in this skill + project CLAUDE.md).
3. Check plans/<project>/plan.md for next phase requirements.
4. If next phase needs different resources, create swarm task for appropriate host.
5. Continue to next work item — don't stop.

"New task from operator mid-session"

1. If operator gives explicit work → do it immediately, it's highest priority.
2. After completing it, resume the work queue where you left off.

Project Registry

Fleet Resource Map

Phase Tracking Convention

Each project uses its own phase prefix:

• M1, M2... (Audit Sentinel milestones)
• H1, H2... (Hashrate Hedger)
• C1, C2... (ClauseHound)
• P1, P2... (Prompt Forge)
• D1, D2... (DocuMint)
• E1, E2... ()

Plans live in <project>/plans/ as markdown files.

Coordination Rules

• Check swarm status before starting work on any shared project.
• Don't work on the same project another instance is actively editing.
• Use git worktrees for parallel work on the same repo.
• Commit frequently — other instances pull your changes.

Repos (19)