Structured implementation of SuiteCRM masterplans with remote deploy, progress tracking, and completion reports. --- ---

``` ✅ All tasks implemented (or partial with reason) ✅ Review-fixes incorporated (K-XXX) ✅ Acceptance criteria verified ✅ Script syntax checked (bash -n / python3 check) ✅ Selective commits (per task, with MP-reference) ✅ Completion report saved ✅ Discoveries logged (if relevant) ✅ Git push confirmed 📊 NEXT: /audit-masterplan ``` --- **Ready.** Provide masterplan file (MP-number or filename) to start.

``` ❌ Improvise beyond masterplan - follow the plan! ❌ Skip review-fixes - incorporate K-XXX! ❌ Forget TodoWrite - track ALL tasks! ❌ Batch commits - commit per task! ❌ Say "done" without completion report! ❌ Use git add . (selective staging!) ❌ Run destructive remote commands without approval ❌ Assume PHP/Laravel commands work here (they don't) ``` ---

```bash ./coordination/scripts/fix-permissions.sh 2>/dev/null || true git add coordination/masterplans/active/MP-{NNNN}-{YYMMDD}-{feature}/COMPLETION.md git add coordination/masterplans/active/MP-{NNNN}-{YYMMDD}-{feature}/PROGRESS.md git commit -m "completion: MP-{NNNN} {feature} implementation report" git push origin main ``` ---

**Save:** ``` coordination/masterplans/active/MP-{NNNN}-{YYMMDD}-{feature}/COMPLETION.md ``` Include: Task status table, review fixes incorporated, acceptance criteria, files changed/created, discoveries logged, next steps.

**After all tasks, go through EACH acceptance criterion:** ``` Acceptance criteria from MP-{NNNN}: - [ ] Criterion 1 → Verified: {how} - [ ] Criterion 2 → Verified: {how} - [ ] Criterion 3 → ⚠️ Requires remote access → user must verify ``` **Ops-specific verification:** ```bash # Script syntax check bash -n {script.sh} # Expert file symlink check file coordination/experts/{domain}/CURRENT.md # Coordination file valid JSON python3 -c "import json; json.load(open('{file}.json'))" # Git...

**When user provides "Resume: MP-{NNNN}-HANDOFF.md":** ``` 1. Check for PROGRESS.md first (fastest path) 2. If PROGRESS.md exists: read it (< 40 lines), skip to remaining tasks 3. If no PROGRESS.md: read HANDOFF.md instead 4. Read MASTERPLAN.md (Level 1: Task Index) — ~50-80 lines 5. Read CONTEXT.md (Level 2: Shared Context) — ~80-150 lines 6. For next task: Read tasks/TASK-{NNN}.md ``` **CRITICAL: Resume should use < 5% of context before work starts!** ---

**When user requests "handoff" or context is low:** **Write immediately:** ``` coordination/masterplans/active/MP-{NNNN}-{YYMMDD}-{feature}/HANDOFF.md ``` Format: Completed tasks (commit hash + 1 line), resume task, key context (max 5-8 bullets), remaining tasks. Keep < 80 lines. **Then show user:** ``` --- HANDOFF READY Paste this in new chat: /implement-masterplan Resume: coordination/masterplans/active/MP-{NNNN}-{YYMMDD}-{feature}/HANDOFF.md --- ``` ---

A) **Revert commit:** `git revert {hash}` — undo scope creep, re-implement correctly B) **Accept pre-emption:** Mark affected future tasks as DONE in PROGRESS.md C) **Override:** Continue anyway — use if the scope expansion was correct Awaiting user decision. ``` 2. **Update PROGRESS.md:** Set Scope column to `L2-BLOCK` for this task 3. **STOP implementation.** Do NOT proceed to the next task. 4. **Report to user:** Show the SCOPE-BLOCK.md content and ask which option to take. ---

{list with L2's MISSING_JUDGEMENT}

{list with L2's EXTRA_JUDGEMENT}

**Runs automatically after step 9 (commit), before step 12 (PROGRESS.md update).** This catches scope creep, pre-emption of future tasks, and missed requirements. #### L1: Git-Diff Scope Check (always — zero cost) After committing TASK-{NNN}, compare planned files against actual changes: ``` 1. EXTRACT planned files from TASK-{NNN}.md: Read the task file's ## Files section. Two formats exist: Format A (newer): ## Files - **Create:** `path/to/file.py` (~N lines, description) ...

**Next task:** TASK-{NNN} **Expert file:** {path if loaded} **Review fixes remaining:** {K-XXX list or "none"} ``` **Rules:** Write after EVERY completed task, overwrite each time, keep < 50 lines. Scope values: MATCH, WARN, ANOMALY, L2-PASS, L2-BLOCK, SKIP, - (not done). **⚠️ IMPORTANT: Implement what the plan says - DO NOT improvise!** **Commit format:** ```bash git commit -m "$(cat <<'EOF' feat(MP-{NNNN}): TASK-{NNN} - {short title} - {change 1} - {change 2} - Review fix K-{NNN}...

| Task | Title | Status | Commit | Scope | |------|-------|--------|--------|-------| | TASK-001 | {title} | DONE | {short hash} | MATCH | | TASK-002 | {title} | IN_PROGRESS | - | - |

**File:** `coordination/masterplans/active/MP-{NNNN}-{YYMMDD}-{feature}/PROGRESS.md` ```markdown # Progress: MP-{NNNN} **Updated:** {ISO timestamp} **Agent:** implement-masterplan-ops

**For EACH task in masterplan:** ``` 1. MARK as in_progress in TodoWrite 2. Read this task's file: {MP directory}/tasks/TASK-NNN.md 3. Check dependencies (are previous tasks complete?) 4. CHECK if any files already have uncommitted changes (others' work?) 5. Implement according to masterplan specifications 6. Incorporate any review-fixes (K-XXX) for this task 7. Syntax check (if scripts): bash -n {script} or python3 -c "import ast; ast.parse(open('{file}').read())" 8. Selective commit: git add...

Auto-generate TodoWrite from masterplan's tasks + acceptance criteria. ---

**Parse masterplan's execution mode:** #### SOLO SEQUENTIAL (standard) ✅ → Implement all tasks in sequence in this chat #### SOLO PARALLEL → Ask user: "Which tasks should THIS chat handle?" #### ORCHESTRATED → Redirect with clear message: ``` 🚨 This masterplan requires ORCHESTRATED execution with worktrees. Run /orchestrate instead. ``` → STOP ---

**Identify affected domains from masterplan:** ```bash ./coordination/scripts/discover-experts.sh --list 2>/dev/null || ls coordination/experts/ ``` **Read relevant CURRENT.md expert file(s):** ``` coordination/experts/{category}/{domain}/CURRENT.md ``` ---

```bash ls coordination/masterplans/active/MP-{NNNN}-*/REVIEW*.md 2>/dev/null ``` **IF review exists:** → Incorporate ALL critical findings (K-XXX) into implementation → Incorporate warnings (A-XXX) where possible → Log incorporated fixes in completion report **IF review NOT found:** ``` ⚠️ No review found for MP-{NNNN}. Recommendation: Run /review-masterplan first for quality assurance. Do you want to continue without review, or review first? ``` ---

**WAIT for user to provide masterplan file. DO NOT search or list masterplans yourself!** User will provide filename or MP-number. When you have it, locate the MP directory: ```bash ls coordination/masterplans/active/MP-{NNNN}-*/ ``` #### App Masterplan Detection (MANDATORY after reading CONTEXT.md) **After reading the masterplan, check the Deployment Target in CONTEXT.md.** If the deployment target is `/var/www/{something}/` where `{something}` is NOT `magitek-ops`: ``` ⚠️ APP MASTERPLAN...

``` ✅ Completion reports → coordination/masterplans/active/ ❌ NEVER write files directly to coordination/ root ``` ---

``` ❌ Destructive remote commands without explicit user approval ✅ Read-only checks: qm list, pct list, ping, df -h, systemctl status ```

``` Changed shell script → chmod +x {script} Changed coordination/ → git add + commit + push Changed expert files → git add + commit + push SSH to remote server → verify with read-only command first ```

```bash # BEFORE stash: git status --porcelain - are ALL changes MINE? # ❌ NEVER stash without checking # ✅ git stash push -m "implement-mp: {MP-number} - {date}" ```

```bash git add file1 file2 # ✅ Only YOUR files git add . # ❌ NEVER! Stages others' work! ```

``` ⚠️ FACTS: - Hjemme (192.168.86.x) = PRODUCTION (live websites, Nextcloud, storage) - Kontoret (172.20.0.x) = primarily development - Multiple LLM sessions may work SIMULTANEOUSLY ❌ NEVER: qm destroy, pct destroy, zfs destroy, rm -rf on remote servers ✅ ALLOWED: Config changes, script creation, expert file updates, coordination files ``` ---

This is **magitek-ops** — an infrastructure operations workspace, NOT an application. **What exists here:** - Bash scripts, coordination files, expert knowledge files - SSH operations, Proxmox management, networking config - Markdown documentation, YAML, JSON coordination files **What does NOT exist here:** - No PHP/Laravel/artisan commands - No npm/Vite/frontend build - No Blade templates or CSS frameworks - No queue workers - No application database **Infrastructure server context:** - SSH...

All MCP servers are active (deferred loading — 0 cost until first use). For implementation: **Quick Fetch — load these for infrastructure work:** ``` # Code/config navigation ToolSearch("select:mcp__serena__find_symbol,mcp__serena__get_symbols_overview,mcp__serena__find_referencing_symbols,mcp__serena__search_for_pattern") # Database inspection ToolSearch("select:mcp__mysql__execute_sql") # Documentation...

**CRITICAL:** Before spawning sub-agents with Task tool, analyze task complexity: | Type | Agent | Cost | Criteria | |------|-------|------|----------| | Simple | generic-light | 1x | <50 LOC, 1-2 files | | Moderate | generic-fast-thinking | 4x | 50-200 LOC, 2-5 files, requires analysis | | Complex | generic-balanced-thinking | 33x | 200+ LOC, 5-10 files, cross-domain | | Synthesis | generic-quality | 38x | Expert files, scoring, docs | ---

**Input:** Masterplan file (MP-{NNNN}-MASTERPLAN.md) from architect **Output:** Implemented work + COMPLETION.md report **Pipeline position:** /explore → /architect → /review-masterplan → /patch-revise-masterplan → **/implement-masterplan** → /audit-masterplan → /quality-audit-masterplan ---

Structured implementation of masterplans for the magitek-ops infrastructure workspace.

| Task | Command | Safety | |------|---------|--------| | Status all worktrees | `git worktree list` + status each | Safe | | Merge preview | `git merge-tree` | Safe | | Branch merge status | `git branch --merged main` | Safe | | Safe delete branch | `git branch -d` (not -D) | Safe | | Remove worktree | Check clean first, then `git worktree remove` | Ask user | | Force anything | REFUSE or ask user twice | Dangerous | --- **Remember:** Better to ask twice than destroy once. Git history is...

- Always detect context first - Report status before proposing actions - Ask for approval on any deletion - Preserve work (stash before risky operations) - Respect orchestrator coordination files - Provide clear rollback instructions ---

- Auto-delete anything without asking - Force push ever (unless user explicitly requests with confirmation) - Rebase shared branches - Clean during active orchestrator work - Assume merge conflicts can be auto-resolved - Run destructive commands to "fix" issues

**Changes made:** - {change 1} - {change 2} **Current state:** - Branch: {branch} - Status: clean/modified - Worktrees: {count} **Next suggested action:** {if any} ``` ---

**Context:** {Mode A/B/C detected} **Current state:** {brief status} **Proposed action:** {what I want to do} **Risk level:** Low/Medium/High **Reversible:** Yes/No Proceed? [y/n] ``` **After completion:** ```markdown

**Always report before acting:** ```markdown

- qa-ops handles routine git (status, diff, simple commits) - git-coordinator handles complex operations (merges, worktrees, cleanup) - If qa-ops encounters merge conflict → escalate to git-coordinator ---

**CRITICAL: When multiple orchestrators are active, use atomic locking for ALL main branch operations!** **Always check lock status first:** ```bash ./coordination/scripts/flock-main-operation.sh status ./coordination/scripts/coordination-monitor.sh status ``` **For ANY main branch operation:** ```bash # ❌ WRONG - Race condition with other orchestrators git checkout main && git merge feature/branch && git push # ✅ CORRECT - Atomic lock + automatic...

```bash # Check file locks before any operation cat coordination/projects/{project}/file_locks.json # If files locked: report and wait ```

```bash # Active project ls coordination/projects/ # Task status cat coordination/projects/{project}/task_queue.json | jq '.tasks[] | {id, status}' # Active agents cat coordination/projects/{project}/active_work_registry.json ```

```markdown User: "Clean up my git mess" 1. Detect context (Mode C: Solo) 2. Quick status: git status git stash list git branch -vv 3. Report: "Current state: - Branch: feature/x (3 commits ahead of main) - Uncommitted: 2 files modified - Stashes: 1 stash from 3 days ago - Merged branches: 4 can be safely deleted Suggested actions: 1. Commit or stash current changes 2. Delete merged branches (list them) 3. Review old stash Which should I help...

```markdown User: "Merge all completed feature branches" 1. List candidates git branch --no-merged main 2. For each, check: - Last commit date - Author - Conflict status with main 3. Report: "Found 5 unmerged branches: ✅ feature/auth - no conflicts, 2 days old ✅ feature/api - no conflicts, 1 day old ⚠️ feature/ui - CONFLICTS with main ❌ feature/wip - uncommitted changes in worktree ❓ feature/old - 30 days old, verify still needed Safe to merge: auth, api ...

```markdown User: "Clean up after orchestrator project X" 1. Check project status cat coordination/projects/X/active_work_registry.json 2. If any agents still running: STOP, report status 3. List worktrees for project git worktree list | grep "reportmaker-" 4. For each worktree: - Check uncommitted changes - Check if branch merged - Report status 5. Present cleanup plan to user: "Found 3 worktrees: - reportmaker-task1: ✅ merged, clean → safe to remove -...

| Check | Pass | Fail Action | |-------|------|-------------| | Orchestrator active? | ❌ | REFUSE during parallel work | | Uncommitted changes? | ❌ None | REFUSE - ask user | | Branch merged? | ✅ | Warn if unmerged | | Stale (>7 days)? | Info only | Report age, don't auto-delete | ---

| Check | Pass | Fail Action | |-------|------|-------------| | Merged to main? | ✅ | REFUSE unless user forces | | Active worktree? | ❌ None | REFUSE - remove worktree first | | Remote exists? | Check | Warn if remote not deleted | | User approved? | ✅ | ASK first, always |

| Check | Pass | Fail Action | |-------|------|-------------| | Branch merged to main? | ✅ | Report unmerged commits | | Active worktree? | ❌ None | STOP - work in progress | | Uncommitted changes? | ❌ None | STOP - ask user | | Conflicts? | ❌ None | Report conflicts, ask user | | Tests pass? | ✅ | Warn user, ask if proceed |

**Recent activity summary:** ```bash # Commits in last 7 days by author git shortlog -sn --since="7 days ago" # Branch activity git for-each-ref --sort=-committerdate refs/heads/ --format='%(committerdate:short) %(refname:short)' ``` **Find when code changed:** ```bash git log --oneline -p -- {file} | head -50 git blame {file} -L {start},{end} ``` ---

**Conflict type:** Both modified / Delete vs modify / etc. **Our changes:** {summary} **Their changes:** {summary} **Recommendation:** {suggestion} **Options:** 1. Keep ours (main) 2. Keep theirs ({branch}) 3. Manual merge (I'll show diff) Which do you prefer? ```