Communitygithub.com

Purple-Horizons/tick-md

Koordiniere Arbeit zwischen Menschen und KI-Agenten mit strukturierten Markdown-Dateien.

Was ist tick-md?

Tick Multi-Agent Coordination ist ein Git-basiertes Task-Koordinationsprotokoll, das in einer einzigen TICK.md-Datei arbeitet. Es ermöglicht KI-Agenten (wie Claude Code, Cursor, Codex) und Menschen, Aufgaben transparent zu erstellen, zuzuweisen, zu bearbeiten und abzuschließen – ohne Cloud-Abhängigkeit. Die Aufgaben werden in menschenlesbarem Markdown mit YAML-Frontmatter gespeichert, maschinenlesbar und versioniert. Unterstützt werden CLI-Befehle und MCP-Tools für direkte Integration in KI-Entwicklungsumgebungen. Fortschritt, Abhängigkeiten und Agentenrollen werden automatisch nachverfolgt.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Purple-Horizons/tick-md/tree/main/clawhub-plugin/skills/tick-coordination
Original anzeigen→Alle Skills durchsuchen

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

OpenAIChatGPTClaudeClaudeGeminiGeminiGrokGrokPerplexityPerplexityDeepSeekDeepSeek

Dokumentation

Tick Multi-Agenten-Koordination

Koordiniere Arbeit zwischen Menschen und KI-Agenten mit strukturierten Markdown-Dateien. Benutzer interagieren natürlich mit dir, und du pflegst Aufgaben transparent in TICK.md.

Installation

Voraussetzungen: Die Tick CLI und der MCP-Server sollten bereits von deiner Umgebung installiert und konfiguriert sein.

Erstmalige Einrichtung? Siehe INSTALL.md für editorspezifische Installationsanleitungen.

Schnellcheck:

# Überprüfe, ob die CLI verfügbar ist
tick --version

# Prüfe, ob TICK.md im Projekt existiert
ls TICK.md

# Falls nicht, initialisieren
tick init

Kernkonzept

Tick-Protokoll = Git-basierte Aufgabenkoordination über TICK.md-Dateien

  • Menschenlesbar: Standard-Markdown mit YAML
  • Maschinenlesbar: Strukturiert für Tools
  • Git-gestützt: Vollständige Versionskontrolle und Prüfpfad
  • Lokal zuerst: Keine Cloud erforderlich

Schnellstart

Prüfen, ob Tick initialisiert ist

ls TICK.md

Falls nicht initialisiert

tick init

Aktuellen Status abrufen

tick status

Häufige Arbeitsabläufe

1. Benutzer bittet dich, etwas zu tun

Benutzer: „Kannst du das Authentifizierungssystem umgestalten?“

Deine Aktionen:

# 1. Aufgabe erstellen
tick add "Authentifizierungssystem umgestalten" --priority high --tags backend,security

# 2. Dich selbst registrieren (nur beim ersten Mal)
tick agent register @dein-name --type bot --roles "engineer,refactoring"

# 3. Aufgabe beanspruchen
tick claim AUFGABE-XXX @dein-name

# 4. Daran arbeiten (die eigentliche Arbeit erledigen)

# 5. Fortschrittskommentare hinzufügen
tick comment AUFGABE-XXX @dein-name --note "Analysiere aktuellen Auth-Fluss"
tick comment AUFGABE-XXX @dein-name --note "Auf JWT-Tokens umgestellt"

# 6. Als erledigt markieren
tick done AUFGABE-XXX @dein-name

2. Benutzer fragt nach Projektstatus

Benutzer: „An welchen Aufgaben arbeiten wir gerade?“

# Umfassenden Status abrufen
tick status

# Oder filtern und Aufgaben auflisten
tick list --status in_progress
tick list --claimed-by @bot-name

Fasse die Ausgabe natürlich für den Benutzer zusammen.

3. Koordination mit anderen Agenten

Benutzer: „Haben die anderen Agenten ihre Aufgaben erledigt?“

# Gesamtstatus prüfen
tick status

# Agenten und ihre Arbeit auflisten
tick agent list --verbose

# Projekt validieren
tick validate

4. Komplexe Arbeit aufteilen

Benutzer: „Erstelle ein Benutzer-Dashboard mit Diagrammen und Datenexport“

Deine Aktionen:

# Übergeordnete Aufgabe erstellen
tick add "Benutzer-Dashboard erstellen" --priority high --tags frontend

# Unteraufgaben mit Abhängigkeiten erstellen
tick add "Dashboard-Layout entwerfen" --priority high --tags frontend,design
tick add "Daten-Diagramme implementieren" --priority medium --tags frontend,charts --depends-on AUFGABE-XXX
tick add "CSV-Export hinzufügen" --priority low --tags frontend,export --depends-on AUFGABE-XXX

# Abhängigkeiten visualisieren
tick graph

Befehlsreferenz

Projektverwaltung

tick init                          # Neues Projekt initialisieren
tick status                        # Projektübersicht anzeigen
tick list                          # Aufgaben mit Filtern auflisten
tick graph                         # Abhängigkeiten visualisieren
tick watch                         # Änderungen in Echtzeit überwachen
tick validate                      # Auf Fehler prüfen
tick sync --push                   # In Git committen und pushen

Aufgabenoperationen

tick add "Aufgabentitel" \
  --priority high \                # urgent|high|medium|low
  --tags backend,api \             # Kommagetrennte Tags
  --assigned-to @agent \           # Agent zuweisen
  --depends-on AUFGABE-001 \       # Abhängigkeiten
  --estimated-hours 4              # Zeitaufwand schätzen

tick claim AUFGABE-001 @agent      # Aufgabe beanspruchen (setzt in_progress)
tick release AUFGABE-001 @agent    # Aufgabe freigeben (zurück zu todo)
tick done AUFGABE-001 @agent       # Aufgabe abschließen
tick reopen AUFGABE-001 @agent     # Abgeschlossene Aufgabe wieder öffnen
tick delete AUFGABE-001            # Aufgabe löschen
tick comment AUFGABE-001 @agent \ # Notiz hinzufügen
  --note "Fortschrittsupdate"
tick edit AUFGABE-001 \            # Direkte Feldbearbeitung
  --title "Neuer Titel" \
  --priority high \
  --status in_progress

Korrekturen & Wiederherstellung

tick reopen AUFGABE-001 @agent        # Abgeschlossene Aufgabe wieder öffnen
tick reopen AUFGABE-001 @agent \      # Wieder öffnen und abhängige wieder blocken
  --re-block

tick delete AUFGABE-001               # Aufgabe löschen, bereinigt Abhängigkeiten
tick delete AUFGABE-001 --force       # Löschen, auch wenn abhängige Aufgaben existieren

tick edit AUFGABE-001 --title "X"     # Titel ändern
tick edit AUFGABE-001 --priority high # Priorität ändern
tick edit AUFGABE-001 --status todo   # Status direkt ändern
tick edit AUFGABE-001 --tags a,b,c    # Tags ersetzen
tick edit AUFGABE-001 --add-tag new   # Tag hinzufügen
tick edit AUFGABE-001 --remove-tag old # Tag entfernen
tick edit AUFGABE-001 \               # Abhängigkeiten bearbeiten
  --depends-on AUFGABE-002,AUFGABE-003

tick undo                          # Letzte Tick-Operation rückgängig machen
tick undo --dry-run                # Vorschau, was rückgängig gemacht würde

Massenoperationen

tick import tasks.yaml             # Aufgaben aus YAML-Datei importieren
tick import - < tasks.yaml         # Von stdin importieren
tick import tasks.yaml --dry-run   # Importvorschau anzeigen

tick batch start                   # Batch-Modus starten (kein Auto-Commit)
tick batch status                  # Batch-Status prüfen
tick batch commit                  # Alle gebatchten Änderungen committen
tick batch abort                   # Gebatchte Änderungen verwerfen

Erweiterte Aufgabenauflistung

tick list                          # Alle Aufgaben, gruppiert nach Status
tick list --status blocked         # Nur blockierte Aufgaben
tick list --priority urgent        # Aufgaben mit hoher Priorität
tick list --assigned-to @alice     # Aufgaben für bestimmten Agenten
tick list --tag backend            # Aufgaben mit Tag
tick list --json                   # JSON-Ausgabe für Skripte

Abhängigkeitsvisualisierung

tick graph                         # ASCII-Abhängigkeitsbaum
tick graph --format mermaid        # Mermaid-Flussdiagramm
tick graph --show-done             # Abgeschlossene Aufgaben einbeziehen

Echtzeit-Überwachung

tick watch                         # Auf Änderungen wachen
tick watch --interval 10           # Benutzerdefiniertes Abrufintervall
tick watch --filter in_progress    # Nur bestimmten Status anzeigen

Agentenverwaltung

tick agent register @name \        # Neuen Agenten registrieren
  --type bot \                     # human|bot
  --roles "dev,qa" \               # Kommagetrennte Rollen
  --status idle                    # working|idle|offline

tick agent list                    # Alle Agenten auflisten
tick agent list --verbose          # Detaillierte Informationen
tick agent list --type bot         # Nach Typ filtern
tick agent list --status working   # Nach Status filtern

MCP-Tools (Alternative zur CLI)

Wenn das Model Context Protocol verwendet wird, nutze diese Tools anstelle von CLI-Befehlen:

Status und Inspektion

  • tick_status - Projektstatus abrufen (Agenten, Aufgaben, Fortschritt)
  • tick_validate - TICK.md-Struktur validieren
  • tick_agent_list - Agenten mit optionalen Filtern auflisten

Aufgabenverwaltung

  • tick_add - Neue Aufgabe erstellen
  • tick_claim - Aufgabe für Agenten beanspruchen
  • tick_release - Beanspruchte Aufgabe freigeben
  • tick_done - Aufgabe abschließen (entsperrt automatisch abhängige)
  • tick_comment - Notiz zur Aufgabe hinzufügen

Korrekturen & Wiederherstellung

  • tick_reopen - Abgeschlossene Aufgabe wieder öffnen
  • tick_delete - Aufgabe löschen
  • tick_edit - Direkte Feldbearbeitung (umgeht die Zustandsmaschine)
  • tick_undo - Letzte Tick-Operation rückgängig machen

Agentenoperationen

  • tick_agent_register - Neuen Agenten registrieren

MCP-Beispiel:

// Aufgabe via MCP erstellen
await tick_add({
  title: "Authentifizierung umgestalten",
  priority: "high",
  tags: ["backend", "security"],
  assignedTo: "@bot-name"
})

// Beanspruchen
await tick_claim({
  taskId: "AUFGABE-023",
  agent: "@bot-name"
})

Best Practices

1. Natürliches Gespräch zuerst

✅ Gut: Benutzer sagt „Auth umgestalten“, du erstellst automatisch die Aufgabe ❌ Schlecht: Benutzer explizit Aufgaben erstellen lassen

2. Immer deinen Agentennamen verwenden

Einmal registrieren:

tick agent register @dein-bot-name --type bot --roles "engineer"

Dann konsistent verwenden:

tick claim AUFGABE-001 @dein-bot-name
tick done AUFGABE-001 @dein-bot-name

3. Kontext in Kommentaren bereitstellen

# ✅ Gut - erklärt was und warum
tick comment AUFGABE-005 @bot --note "Von REST auf GraphQL umgestellt für bessere Typsicherheit und reduziertes Over-Fetching"

# ❌ Schlecht - zu vage
tick comment AUFGABE-005 @bot --note "API aktualisiert"

4. Große Aufgaben aufteilen

Unteraufgaben mit Abhängigkeiten erstellen:

tick add "CI/CD-Pipeline einrichten" --priority high
tick add "GitHub Actions konfigurieren" --depends-on AUFGABE-010
tick add "Bereitstellungsskripte hinzufügen" --depends-on AUFGABE-011
tick add "Staging-Umgebung einrichten" --depends-on AUFGABE-011

5. Status vor dem Beanspruchen prüfen

# Sicherstellen, dass die Aufgabe existiert und nicht beansprucht ist
tick status

# Dann beanspruchen
tick claim AUFGABE-XXX @dein-name

Die TICK.md-Struktur verstehen

Die Datei besteht aus drei Abschnitten:

  1. Frontmatter (YAML): Projekt-Metadaten
  2. Agententabelle (Markdown): Wer arbeitet woran
  3. Aufgabenblöcke (YAML + Markdown): Einzelne Aufgaben mit Verlauf

Beispiel:

---
project: meine-app
schema_version: "1.0"
next_id: 5
---

# Agenten

| Name | Typ | Rollen | Status | Arbeitet an |
|------|-----|--------|--------|-------------|
| @alice | mensch | besitzer | working | AUFGABE-003 |
| @bot | bot | entwickler | idle | - |

# Aufgaben

\(backslash)```yaml
id: AUFGABE-001
title: Authentifizierung erstellen
status: done
priority: high
claimed_by: null
# ... weitere Felder
history:
  - ts: 2026-02-07T10:00:00Z
    who: @bot
    action: created
  - ts: 2026-02-07T14:00:00Z
    who: @bot
    action: done
\(backslash)```

JWT-basierte Authentifizierung mit Token-Refresh implementiert...

Erweiterte Funktionen

Automatisches Entsperren von Abhängigkeiten

Wenn du eine Aufgabe abschließt, werden abhängige Aufgaben automatisch entsperrt:

# AUFGABE-002 hängt von AUFGABE-001 ab
# AUFGABE-002 status: blocked

tick done AUFGABE-001 @bot
# AUFGABE-002 wechselt automatisch zu: todo

Erkennung zirkulärer Abhängigkeiten

Die Validierung erkennt zirkuläre Abhängigkeiten:

tick validate
# Fehler: Zirkuläre Abhängigkeit erkannt: AUFGABE-001 → AUFGABE-002 → AUFGABE-003 → AUFGABE-001

Intelligente Commit-Nachrichten

tick sync --push
# Erzeugt automatisch: "feat: complete AUFGABE-001, AUFGABE-002; update AUFGABE-003"

Abgeschlossene Aufgaben wieder öffnen

Falls eine Aufgabe vorzeitig als erledigt markiert wurde:

tick reopen AUFGABE-001 @bot
# Setzt Status zurück auf in_progress, zeichnet im Verlauf auf

tick reopen AUFGABE-001 @bot --re-block
# Blockiert auch alle Aufgaben, die von dieser abhängen, erneut

Fehler korrigieren

# Letzte Tick-Operation rückgängig machen
tick undo

# Vorschau anzeigen, was rückgängig gemacht würde
tick undo --dry-run

# Direkte Feldbearbeitung (umgeht die Zustandsmaschine)
tick edit AUFGABE-001 --status todo --priority urgent

Batch-Operationen

Für mehrere Änderungen ohne einzelne Commits:

tick batch start
# Nun mehrere Änderungen durchführen...
tick add "Aufgabe 1" --priority high
tick add "Aufgabe 2" --priority medium
tick claim AUFGABE-001 @bot
# ...
tick batch commit   # Einzelner Commit für alle Änderungen
# Oder: tick batch abort  # Alle Änderungen verwerfen

Echtzeit-Überwachung

tick watch
# [10:23:45] ✓ Hinzugefügt: AUFGABE-015 - Benutzersuche implementieren
# [10:24:12] 🔒 AUFGABE-015 beansprucht von @bot
# [10:26:33] ⟳ AUFGABE-015: in_progress → done

Kurzreferenz-Karte

Workflow:      init → add → claim → work → comment → done → sync
Wesentlich:    status | add | claim | done | list | graph
Korrekturen:   reopen | delete | edit | undo
Massen:        import | batch start/commit/abort
Koordination:  agent register | agent list | validate | watch
Git:           sync --pull | sync --push

Wichtige Erinnerungen

  1. Benutzer interagieren mit DIR, nicht direkt mit Tick
  2. DU pflegst die TICK.md transparent
  3. Dashboard dient der Einsicht, nicht der primären Interaktion
  4. Verwende immer konsistent deinen Agentennamen
  5. Kommentiere häufig, um Fortschritt zu zeigen
  6. Validiere vor dem Synchronisieren
  7. Prüfe den Status vor dem Beanspruchen
  8. Teile komplexe Arbeit in Unteraufgaben auf

Ressourcen

Lizenz

MIT

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Purple-Horizons/tick-md

# Tick Multi-Agent Coordination

Verwandte Skills

steipete/sag

ElevenLabs text-to-speech with mac-style say UX.

community

steipete/oracle

Oracle CLI second-model review/debug/refactor/design with selected files, dry-run token checks, API or browser engine.

community

steipete/peekaboo

Capture and automate macOS UI with the Peekaboo CLI.

community

mattpocock/design-an-interface

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

community

mattpocock/prototype

Build a throwaway prototype to flesh out a design — a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route.

community

mattpocock/grill-me

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

community