#260 - feat(ui): TodoList & PlanMode - Bessere Erfassung und Darstellung - customable/claude-mem

jack commented

2026-01-25 11:01:52 +00:00

Owner

Übersicht

Implementierung einer verbesserten TodoList- und PlanMode-Darstellung im UI, inklusive besserer Datenerfassung von CLI-Tools (Claude Code und zukünftig andere).

Recherche-Ergebnisse

Aktueller Stand

Datenstrukturen:

observations Tabelle mit Typen task und plan existiert bereits
Keine dedizierten Felder für Task-Status, Due-Date, oder Completion
ObservationLink Tabelle existiert für Verknüpfungen (depends_on, blocks, etc.)

UI:

Kein dedizierter TodoList/PlanMode View
Tasks/Plans nur als Observations in Memories-View sichtbar
Icons: ph--check-square (task), ph--list-checks (plan)

Datenerfassung von Claude Code:

subagent-start / subagent-stop Events werden erfasst
Nicht erfasst: TaskCreate, TaskUpdate, EnterPlanMode, ExitPlanMode
Nur ID und Typ, keine Task-Beschreibung oder Status-Updates

Verfügbare Claude Code Hook-Events

Event	Beschreibung	Aktuell erfasst?
`SubagentStop`	Task/Skill beendet	✅ Ja (nur ID/Typ)
`PostToolUse`	Nach Tool-Ausführung	✅ Ja
`Stop`	Session beendet	✅ Ja
`PreToolUse`	Vor Tool-Ausführung	❌ Nein

Hook Input enthält:

{
  "session_id": "abc123",
  "cwd": "/path",
  "permission_mode": "default|plan|acceptEdits|...",
  "tool_name": "TaskCreate|TaskUpdate|...",
  "tool_input": { ... }
}

Wichtig: permission_mode: "plan" zeigt PlanMode an!

Anforderungen

1. CLI-Agnostisches Design

Kritisch: System muss unabhängig von Claude Code funktionieren.

┌─────────────────────────────────────────────────────────┐
│                    claude-mem Backend                    │
├─────────────────────────────────────────────────────────┤
│                   Generic Task API                       │
│  POST /api/tasks  GET /api/tasks  PATCH /api/tasks/:id  │
├─────────────────────────────────────────────────────────┤
│                     CLI Adapters                         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
│  │ Claude   │  │ Cursor   │  │ Aider    │  │ Manual  │ │
│  │ Code     │  │ AI       │  │          │  │ Input   │ │
│  └──────────┘  └──────────┘  └──────────┘  └─────────┘ │
└─────────────────────────────────────────────────────────┘

Generische Task-Entity:

interface Task {
  id: string;
  title: string;
  description?: string;
  status: 'pending' | 'in_progress' | 'completed' | 'blocked';
  priority?: 'low' | 'medium' | 'high';
  dueDate?: Date;
  completedAt?: Date;
  
  // Hierarchie
  parentId?: string;        // Plan-Task Zuordnung
  children?: Task[];
  
  // Verknüpfungen
  blockedBy?: string[];     // Task-IDs die diesen blocken
  blocks?: string[];        // Task-IDs die dieser blockt
  
  // Kontext
  sessionId?: string;       // Zugehörige Session
  project?: string;
  source: 'claude-code' | 'cursor' | 'manual' | 'api';
  
  // Metadaten
  createdAt: Date;
  updatedAt: Date;
}

2. Erweiterte Datenerfassung (Claude Code)

Neue Hook-Handler:

PreToolUse für TaskCreate - Erfasst Task-Beschreibung und Parameter
PostToolUse für TaskUpdate - Erfasst Status-Änderungen
permission_mode auswerten für PlanMode-Erkennung

Zu erfassende Daten:

// TaskCreate Event
{
  tool_name: 'TaskCreate',
  tool_input: {
    subject: string;
    description: string;
    activeForm?: string;
  }
}

// TaskUpdate Event  
{
  tool_name: 'TaskUpdate',
  tool_input: {
    taskId: string;
    status?: 'pending' | 'in_progress' | 'completed';
    addBlockedBy?: string[];
    addBlocks?: string[];
  }
}

3. UI-Komponenten

Dedizierter Tasks-View mit zwei Modi:

Liste-Ansicht

┌─────────────────────────────────────────────────────────┐
│  Tasks                           [+ Neu] [Kanban/Liste] │
├─────────────────────────────────────────────────────────┤
│  Filter: [Alle ▼] [Projekt ▼] [Status ▼]  🔍 Suche     │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  📋 Plan: API Refactoring (3/5 abgeschlossen)          │
│  ├─ ✅ Endpoints definieren                             │
│  ├─ ✅ Types erstellen                                  │
│  ├─ 🔄 Routes implementieren (in Arbeit)               │
│  ├─ ⬜ Tests schreiben                                  │
│  └─ ⬜ Dokumentation                                    │
│                                                         │
│  ☑️ Fix Login Bug                          heute fällig │
│  ☑️ Dependencies updaten                   ⚠️ blockiert │
│                                                         │
└─────────────────────────────────────────────────────────┘

Kanban-Ansicht

┌─────────────────────────────────────────────────────────┐
│  Pending        │  In Progress    │  Completed          │
├─────────────────┼─────────────────┼─────────────────────┤
│  ┌───────────┐  │  ┌───────────┐  │  ┌───────────┐      │
│  │ Task 1    │  │  │ Task 3    │  │  │ Task 5    │      │
│  │ #session  │  │  │ 🔄 aktiv  │  │  │ ✅ done   │      │
│  └───────────┘  │  └───────────┘  │  └───────────┘      │
│  ┌───────────┐  │                 │  ┌───────────┐      │
│  │ Task 2    │  │                 │  │ Task 6    │      │
│  │ ⚠️blocked │  │                 │  │ ✅ done   │      │
│  └───────────┘  │                 │  └───────────┘      │
└─────────────────┴─────────────────┴─────────────────────┘

4. UI/UX Best Practices (2026)

Basierend auf aktuellen Design-Trends:

Minimalistisches Design mit Micro-Interactions
Klare Hierarchie - Plans > Tasks > Subtasks
Drag & Drop für Status-Änderungen (Kanban)
Keyboard Navigation für Power-User
Dark Mode Support
Responsive Design für Mobile
Inline-Editing für schnelle Änderungen
Progress Indicators für Plans (3/5 Tasks)
Filter & Suche mit Echtzeit-Ergebnissen
Dependency Visualization (welche Tasks blocken)

Technische Umsetzung

Phase 1: Datenmodell & API

Task-Entity in packages/database erstellen (oder Observation erweitern)
Task-Repository mit CRUD-Operationen
REST API Endpoints: /api/tasks/*
WebSocket Events für Echtzeit-Updates

Phase 2: Claude Code Adapter

PreToolUse Handler für TaskCreate/TaskUpdate
PlanMode-Erkennung via permission_mode
Task-Lifecycle Events an Backend senden
Bestehende subagent-Events mit Task-Daten anreichern

Phase 3: UI Implementation

Tasks-View als neue Route in App.tsx
TaskList-Komponente (Liste mit Hierarchie)
TaskBoard-Komponente (Kanban)
TaskCard-Komponente (einzelner Task)
TaskDetail-Modal (Vollansicht/Bearbeitung)
Manuelle Task-Erstellung (CLI-unabhängig)

Phase 4: Erweiterungen

Bulk-Operationen (mehrere Tasks abschließen)
Task-Templates
Recurring Tasks
Notifications bei Status-Änderungen
Export (Markdown, JSON)

Referenzen

Abhängigkeiten

Könnte von #197 (Database Schema Redesign) profitieren
Nutzt bestehende ObservationLink-Infrastruktur

## Übersicht Implementierung einer verbesserten TodoList- und PlanMode-Darstellung im UI, inklusive besserer Datenerfassung von CLI-Tools (Claude Code und zukünftig andere). ## Recherche-Ergebnisse ### Aktueller Stand **Datenstrukturen:** - `observations` Tabelle mit Typen `task` und `plan` existiert bereits - Keine dedizierten Felder für Task-Status, Due-Date, oder Completion - `ObservationLink` Tabelle existiert für Verknüpfungen (depends_on, blocks, etc.) **UI:** - Kein dedizierter TodoList/PlanMode View - Tasks/Plans nur als Observations in Memories-View sichtbar - Icons: `ph--check-square` (task), `ph--list-checks` (plan) **Datenerfassung von Claude Code:** - `subagent-start` / `subagent-stop` Events werden erfasst - **Nicht erfasst:** TaskCreate, TaskUpdate, EnterPlanMode, ExitPlanMode - Nur ID und Typ, keine Task-Beschreibung oder Status-Updates ### Verfügbare Claude Code Hook-Events | Event | Beschreibung | Aktuell erfasst? | |-------|--------------|------------------| | `SubagentStop` | Task/Skill beendet | ✅ Ja (nur ID/Typ) | | `PostToolUse` | Nach Tool-Ausführung | ✅ Ja | | `Stop` | Session beendet | ✅ Ja | | `PreToolUse` | Vor Tool-Ausführung | ❌ Nein | **Hook Input enthält:** ```json { "session_id": "abc123", "cwd": "/path", "permission_mode": "default|plan|acceptEdits|...", "tool_name": "TaskCreate|TaskUpdate|...", "tool_input": { ... } } ``` **Wichtig:** `permission_mode: "plan"` zeigt PlanMode an! --- ## Anforderungen ### 1. CLI-Agnostisches Design **Kritisch:** System muss unabhängig von Claude Code funktionieren. ``` ┌─────────────────────────────────────────────────────────┐ │ claude-mem Backend │ ├─────────────────────────────────────────────────────────┤ │ Generic Task API │ │ POST /api/tasks GET /api/tasks PATCH /api/tasks/:id │ ├─────────────────────────────────────────────────────────┤ │ CLI Adapters │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌─────────┐ │ │ │ Claude │ │ Cursor │ │ Aider │ │ Manual │ │ │ │ Code │ │ AI │ │ │ │ Input │ │ │ └──────────┘ └──────────┘ └──────────┘ └─────────┘ │ └─────────────────────────────────────────────────────────┘ ``` **Generische Task-Entity:** ```typescript interface Task { id: string; title: string; description?: string; status: 'pending' | 'in_progress' | 'completed' | 'blocked'; priority?: 'low' | 'medium' | 'high'; dueDate?: Date; completedAt?: Date; // Hierarchie parentId?: string; // Plan-Task Zuordnung children?: Task[]; // Verknüpfungen blockedBy?: string[]; // Task-IDs die diesen blocken blocks?: string[]; // Task-IDs die dieser blockt // Kontext sessionId?: string; // Zugehörige Session project?: string; source: 'claude-code' | 'cursor' | 'manual' | 'api'; // Metadaten createdAt: Date; updatedAt: Date; } ``` ### 2. Erweiterte Datenerfassung (Claude Code) **Neue Hook-Handler:** - [ ] `PreToolUse` für `TaskCreate` - Erfasst Task-Beschreibung und Parameter - [ ] `PostToolUse` für `TaskUpdate` - Erfasst Status-Änderungen - [ ] `permission_mode` auswerten für PlanMode-Erkennung **Zu erfassende Daten:** ```typescript // TaskCreate Event { tool_name: 'TaskCreate', tool_input: { subject: string; description: string; activeForm?: string; } } // TaskUpdate Event { tool_name: 'TaskUpdate', tool_input: { taskId: string; status?: 'pending' | 'in_progress' | 'completed'; addBlockedBy?: string[]; addBlocks?: string[]; } } ``` ### 3. UI-Komponenten **Dedizierter Tasks-View mit zwei Modi:** #### Liste-Ansicht ``` ┌─────────────────────────────────────────────────────────┐ │ Tasks [+ Neu] [Kanban/Liste] │ ├─────────────────────────────────────────────────────────┤ │ Filter: [Alle ▼] [Projekt ▼] [Status ▼] 🔍 Suche │ ├─────────────────────────────────────────────────────────┤ │ │ │ 📋 Plan: API Refactoring (3/5 abgeschlossen) │ │ ├─ ✅ Endpoints definieren │ │ ├─ ✅ Types erstellen │ │ ├─ 🔄 Routes implementieren (in Arbeit) │ │ ├─ ⬜ Tests schreiben │ │ └─ ⬜ Dokumentation │ │ │ │ ☑️ Fix Login Bug heute fällig │ │ ☑️ Dependencies updaten ⚠️ blockiert │ │ │ └─────────────────────────────────────────────────────────┘ ``` #### Kanban-Ansicht ``` ┌─────────────────────────────────────────────────────────┐ │ Pending │ In Progress │ Completed │ ├─────────────────┼─────────────────┼─────────────────────┤ │ ┌───────────┐ │ ┌───────────┐ │ ┌───────────┐ │ │ │ Task 1 │ │ │ Task 3 │ │ │ Task 5 │ │ │ │ #session │ │ │ 🔄 aktiv │ │ │ ✅ done │ │ │ └───────────┘ │ └───────────┘ │ └───────────┘ │ │ ┌───────────┐ │ │ ┌───────────┐ │ │ │ Task 2 │ │ │ │ Task 6 │ │ │ │ ⚠️blocked │ │ │ │ ✅ done │ │ │ └───────────┘ │ │ └───────────┘ │ └─────────────────┴─────────────────┴─────────────────────┘ ``` ### 4. UI/UX Best Practices (2026) Basierend auf aktuellen Design-Trends: - [ ] **Minimalistisches Design** mit Micro-Interactions - [ ] **Klare Hierarchie** - Plans > Tasks > Subtasks - [ ] **Drag & Drop** für Status-Änderungen (Kanban) - [ ] **Keyboard Navigation** für Power-User - [ ] **Dark Mode** Support - [ ] **Responsive Design** für Mobile - [ ] **Inline-Editing** für schnelle Änderungen - [ ] **Progress Indicators** für Plans (3/5 Tasks) - [ ] **Filter & Suche** mit Echtzeit-Ergebnissen - [ ] **Dependency Visualization** (welche Tasks blocken) --- ## Technische Umsetzung ### Phase 1: Datenmodell & API - [ ] Task-Entity in `packages/database` erstellen (oder Observation erweitern) - [ ] Task-Repository mit CRUD-Operationen - [ ] REST API Endpoints: `/api/tasks/*` - [ ] WebSocket Events für Echtzeit-Updates ### Phase 2: Claude Code Adapter - [ ] `PreToolUse` Handler für TaskCreate/TaskUpdate - [ ] PlanMode-Erkennung via `permission_mode` - [ ] Task-Lifecycle Events an Backend senden - [ ] Bestehende subagent-Events mit Task-Daten anreichern ### Phase 3: UI Implementation - [ ] Tasks-View als neue Route in App.tsx - [ ] TaskList-Komponente (Liste mit Hierarchie) - [ ] TaskBoard-Komponente (Kanban) - [ ] TaskCard-Komponente (einzelner Task) - [ ] TaskDetail-Modal (Vollansicht/Bearbeitung) - [ ] Manuelle Task-Erstellung (CLI-unabhängig) ### Phase 4: Erweiterungen - [ ] Bulk-Operationen (mehrere Tasks abschließen) - [ ] Task-Templates - [ ] Recurring Tasks - [ ] Notifications bei Status-Änderungen - [ ] Export (Markdown, JSON) --- ## Referenzen - [Claude Code Hooks Dokumentation](https://docs.claude.com/en/docs/claude-code/hooks) - [List UI Design Best Practices](https://www.justinmind.com/ui-design/list) - [UI/UX Design Trends 2026](https://uidesignz.com/blogs/ui-ux-design-best-practices) - [Todo List UI Case Study](https://blog.tubikstudio.com/case-study-upper-app-ui-design-for-to-do-list/) --- ## Abhängigkeiten - Könnte von #197 (Database Schema Redesign) profitieren - Nutzt bestehende ObservationLink-Infrastruktur

jack added the

labels

2026-01-25 11:01:53 +00:00

jack commented

2026-01-25 11:04:34 +00:00

Author

Owner

Ergänzende Recherche: Claude Code Hook-Strukturen & Andere CLIs

Claude Code SubagentStart Input (Offizielle Docs)

{
  "session_id": "abc123",
  "transcript_path": "~/.claude/projects/.../abc123.jsonl",
  "cwd": "/Users/...",
  "permission_mode": "default",
  "hook_event_name": "SubagentStart",
  "agent_id": "agent-abc123",
  "agent_type": "Explore"
}

Wichtige Felder:

agent_id - Eindeutige ID des Subagents
agent_type - Typ: "Bash", "Explore", "Plan", oder Custom Agent Names
permission_mode - Zeigt aktuellen Modus: "default", "plan", "acceptEdits", "dontAsk", "bypassPermissions"

SubagentStop Input

{
  "session_id": "abc123",
  "transcript_path": "~/.claude/projects/.../abc123.jsonl",
  "cwd": "/Users/...",
  "permission_mode": "default",
  "hook_event_name": "SubagentStop",
  "stop_hook_active": false,
  "agent_id": "def456",
  "agent_transcript_path": "~/.claude/projects/.../abc123/subagents/agent-def456.jsonl"
}

Wichtig: agent_transcript_path enthält das vollständige Transkript des Subagents - daraus könnten Task-Details extrahiert werden!

Vergleich: Wie andere CLIs Tasks/Plans implementieren

1. Cursor AI - Plan Mode

Quelle: Cursor Plan Mode, Cursor Docs

Aktivierung: Shift + Tab im Agent Input

Features:

Crawlt das Projekt, liest Docs und Rules
Stellt klärende Fragen
Generiert editierbare Markdown-Datei mit:
- File-Paths und Code-Referenzen
- Todo-Liste
Plan kann direkt bearbeitet werden (inline editing)
Plan wird im Repo gespeichert

Multi-Agent-Ansatz (2026):

Dedicated Agent Layout in Sidebar
Multiple Agents parallel (Refactoring, Tests, UI)
Agents als "kleine Team-Mitglieder"

Todo2 Extension:

AI-powered Project Management direkt im Editor
Kanban-Board integriert
Auto-Research für Best Practices

2. Aider - Architect Mode

Quelle: Aider Review, AiderDesk

Chat Modes:

/mode code - Default, direkte Code-Änderungen
/mode architect - Planung, Design-Patterns, Architektur

Git-Integration:

Automatische Commits für jede AI-Änderung
Klare Commit-Messages
Einfaches Undo/Review

AiderDesk (GUI Wrapper) - Task Lifecycle:

Todo → In Progress → More Info Needed → Ready for Review → Done

Features:

Multi-Step Planning ("implement OAuth" → actionable steps)
Cost Tracking pro Task
Todo-Listen mit Checklist-Management
Git Worktree Isolation für Experimente
Chat History pro Task

3. GitHub Copilot Workspace

Quelle: GitHub Next, GitHub Docs

Workflow:

Spec erstellen - Problem beschreiben
Plan generieren - Liste aller Dateien + Bullet-Points pro Datei
Plan editieren - Instructions/Files anpassen
Implementieren - File-Updates mit Progress-Tracking

UI-Konzept:

Queued file updates auf der rechten Seite
In-Progress / Done Status pro Datei
Iteratives Update einzelner Files

Plan Mode (Public Preview):

Analysiert Codebase
Generiert detaillierte Execution Plans
Validiert Requirements vor dem Coding
Keine Code-Änderungen bis Plan approved

Performance: GPT-5 und Claude Sonnet 4 zeigten ~15% bessere Erfolgsrate mit Planning Workflow

Erkenntnisse für claude-mem

Was wir übernehmen sollten:

Feature	Cursor	Aider	Copilot	Für uns
Markdown-basierte Pläne	✅	❌	✅	✅ Pläne als Markdown speichern
Task-Lifecycle States	❌	✅	✅	✅ Todo→Progress→Review→Done
Inline Plan Editing	✅	❌	✅	⚠️ Später (UI komplex)
Multi-Agent View	✅	❌	❌	✅ Passt zu Worker-System
Git Integration	❌	✅	✅	✅ Commits mit Tasks verknüpfen
Cost Tracking	❌	✅	❌	✅ Token-Kosten pro Task
Kanban Board	✅	✅	❌	✅ Bereits geplant

Datenerfassung erweitern:

agent_transcript_path parsen - Enthält vollständiges Task-Transkript
permission_mode: "plan" tracken - PlanMode-Sessions markieren
agent_type nutzen - Unterscheidung Explore/Plan/Bash/Custom
PreToolUse für TaskCreate/TaskUpdate - Task-Parameter erfassen

CLI-Agnostisches Schema:

interface UniversalTask {
  // Core
  id: string;
  title: string;
  description?: string;
  
  // Lifecycle (wie AiderDesk)
  status: 'todo' | 'in_progress' | 'more_info_needed' | 'ready_for_review' | 'done';
  
  // Plan-Hierarchie (wie Copilot)
  planId?: string;
  steps?: string[];  // Markdown bullets
  affectedFiles?: string[];
  
  // Tracking (wie AiderDesk)
  costTokens?: number;
  costUsd?: number;
  
  // Source-Agnostic
  source: 'claude-code' | 'cursor' | 'aider' | 'copilot' | 'manual' | 'api';
  sourceMetadata?: Record<string, unknown>;
}

Referenzen

## Ergänzende Recherche: Claude Code Hook-Strukturen & Andere CLIs ### Claude Code SubagentStart Input (Offizielle Docs) ```json { "session_id": "abc123", "transcript_path": "~/.claude/projects/.../abc123.jsonl", "cwd": "/Users/...", "permission_mode": "default", "hook_event_name": "SubagentStart", "agent_id": "agent-abc123", "agent_type": "Explore" } ``` **Wichtige Felder:** - `agent_id` - Eindeutige ID des Subagents - `agent_type` - Typ: `"Bash"`, `"Explore"`, `"Plan"`, oder Custom Agent Names - `permission_mode` - Zeigt aktuellen Modus: `"default"`, `"plan"`, `"acceptEdits"`, `"dontAsk"`, `"bypassPermissions"` ### SubagentStop Input ```json { "session_id": "abc123", "transcript_path": "~/.claude/projects/.../abc123.jsonl", "cwd": "/Users/...", "permission_mode": "default", "hook_event_name": "SubagentStop", "stop_hook_active": false, "agent_id": "def456", "agent_transcript_path": "~/.claude/projects/.../abc123/subagents/agent-def456.jsonl" } ``` **Wichtig:** `agent_transcript_path` enthält das vollständige Transkript des Subagents - daraus könnten Task-Details extrahiert werden! --- ## Vergleich: Wie andere CLIs Tasks/Plans implementieren ### 1. Cursor AI - Plan Mode **Quelle:** [Cursor Plan Mode](https://cursor.com/blog/plan-mode), [Cursor Docs](https://cursor.com/docs/agent/planning) **Aktivierung:** `Shift + Tab` im Agent Input **Features:** - Crawlt das Projekt, liest Docs und Rules - Stellt klärende Fragen - Generiert editierbare Markdown-Datei mit: - File-Paths und Code-Referenzen - Todo-Liste - Plan kann direkt bearbeitet werden (inline editing) - Plan wird im Repo gespeichert **Multi-Agent-Ansatz (2026):** - Dedicated Agent Layout in Sidebar - Multiple Agents parallel (Refactoring, Tests, UI) - Agents als "kleine Team-Mitglieder" **Todo2 Extension:** - AI-powered Project Management direkt im Editor - Kanban-Board integriert - Auto-Research für Best Practices ### 2. Aider - Architect Mode **Quelle:** [Aider Review](https://www.blott.com/blog/aider-review-a-developers-month-with-this-terminal-based-code-assistant), [AiderDesk](https://github.com/hotovo/aider-desk) **Chat Modes:** - `/mode code` - Default, direkte Code-Änderungen - `/mode architect` - Planung, Design-Patterns, Architektur **Git-Integration:** - Automatische Commits für jede AI-Änderung - Klare Commit-Messages - Einfaches Undo/Review **AiderDesk (GUI Wrapper) - Task Lifecycle:** ``` Todo → In Progress → More Info Needed → Ready for Review → Done ``` **Features:** - Multi-Step Planning ("implement OAuth" → actionable steps) - Cost Tracking pro Task - Todo-Listen mit Checklist-Management - Git Worktree Isolation für Experimente - Chat History pro Task ### 3. GitHub Copilot Workspace **Quelle:** [GitHub Next](https://githubnext.com/projects/copilot-workspace), [GitHub Docs](https://docs.github.com/en/copilot/tutorials/plan-a-project) **Workflow:** 1. **Spec erstellen** - Problem beschreiben 2. **Plan generieren** - Liste aller Dateien + Bullet-Points pro Datei 3. **Plan editieren** - Instructions/Files anpassen 4. **Implementieren** - File-Updates mit Progress-Tracking **UI-Konzept:** - Queued file updates auf der rechten Seite - In-Progress / Done Status pro Datei - Iteratives Update einzelner Files **Plan Mode (Public Preview):** - Analysiert Codebase - Generiert detaillierte Execution Plans - Validiert Requirements vor dem Coding - **Keine Code-Änderungen bis Plan approved** **Performance:** GPT-5 und Claude Sonnet 4 zeigten ~15% bessere Erfolgsrate mit Planning Workflow --- ## Erkenntnisse für claude-mem ### Was wir übernehmen sollten: | Feature | Cursor | Aider | Copilot | Für uns | |---------|--------|-------|---------|---------| | Markdown-basierte Pläne | ✅ | ❌ | ✅ | ✅ Pläne als Markdown speichern | | Task-Lifecycle States | ❌ | ✅ | ✅ | ✅ Todo→Progress→Review→Done | | Inline Plan Editing | ✅ | ❌ | ✅ | ⚠️ Später (UI komplex) | | Multi-Agent View | ✅ | ❌ | ❌ | ✅ Passt zu Worker-System | | Git Integration | ❌ | ✅ | ✅ | ✅ Commits mit Tasks verknüpfen | | Cost Tracking | ❌ | ✅ | ❌ | ✅ Token-Kosten pro Task | | Kanban Board | ✅ | ✅ | ❌ | ✅ Bereits geplant | ### Datenerfassung erweitern: 1. **`agent_transcript_path` parsen** - Enthält vollständiges Task-Transkript 2. **`permission_mode: "plan"` tracken** - PlanMode-Sessions markieren 3. **`agent_type` nutzen** - Unterscheidung Explore/Plan/Bash/Custom 4. **PreToolUse für TaskCreate/TaskUpdate** - Task-Parameter erfassen ### CLI-Agnostisches Schema: ```typescript interface UniversalTask { // Core id: string; title: string; description?: string; // Lifecycle (wie AiderDesk) status: 'todo' | 'in_progress' | 'more_info_needed' | 'ready_for_review' | 'done'; // Plan-Hierarchie (wie Copilot) planId?: string; steps?: string[]; // Markdown bullets affectedFiles?: string[]; // Tracking (wie AiderDesk) costTokens?: number; costUsd?: number; // Source-Agnostic source: 'claude-code' | 'cursor' | 'aider' | 'copilot' | 'manual' | 'api'; sourceMetadata?: Record<string, unknown>; } ``` --- ## Referenzen - [Claude Code Hooks Reference](https://code.claude.com/docs/en/hooks) - [Cursor Plan Mode Blog](https://cursor.com/blog/plan-mode) - [Cursor Docs - Planning](https://cursor.com/docs/agent/planning) - [AiderDesk GitHub](https://github.com/hotovo/aider-desk) - [GitHub Copilot Workspace](https://githubnext.com/projects/copilot-workspace) - [GitHub Copilot Plan Mode Changelog](https://github.blog/changelog/2025-11-18-plan-mode-in-github-copilot-now-in-public-preview-in-jetbrains-eclipse-and-xcode/)

jack commented

2026-01-25 11:07:55 +00:00

Author

Owner

Ergänzende Recherche: Subagents & Custom Agents

Claude Code Built-in Subagents

Agent	Model	Tools	Zweck
Explore	Haiku (schnell)	Read-only (kein Write/Edit)	Codebase durchsuchen, Dateien finden
Plan	Inherits	Read-only	Research für Plan-Mode
general-purpose	Inherits	Alle Tools	Komplexe Multi-Step Tasks
Bash	Inherits	Bash	Terminal-Befehle in separatem Kontext
statusline-setup	Sonnet	-	`/statusline` Konfiguration
claude-code-guide	Haiku	-	Fragen zu Claude Code Features

Quelle: Claude Code Subagents Docs

Explore Agent Details

Thoroughness Levels: quick | medium | very thorough
Zweck: Exploration aus Main-Conversation raushalten (Context schonen)
Wichtig: Subagents können KEINE anderen Subagents spawnen

Custom Subagent Erstellung

Speicherorte (Priorität):

Location	Scope	Priorität
`--agents` CLI Flag	Aktuelle Session	1 (höchste)
`.claude/agents/`	Projekt	2
`~/.claude/agents/`	Alle Projekte	3
Plugin `agents/`	Plugin-Scope	4 (niedrigste)

Subagent Markdown-Format:

---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Glob, Grep
disallowedTools: Write, Edit
model: sonnet  # oder: inherit, opus, haiku
permissionMode: default  # oder: acceptEdits, dontAsk, bypassPermissions, plan
skills:
  - api-conventions
hooks:
  PreToolUse:
    - matcher: "Bash"
      hooks:
        - type: command
          command: "./scripts/validate.sh"
---

You are a code reviewer. When invoked, analyze the code...

Verfügbare Frontmatter-Felder

Feld	Required	Beschreibung
`name`	✅	Eindeutiger Identifier (lowercase, hyphens)
`description`	✅	Wann Claude delegieren soll
`tools`	❌	Erlaubte Tools (Allowlist)
`disallowedTools`	❌	Verbotene Tools (Denylist)
`model`	❌	`sonnet`, `opus`, `haiku`, `inherit`
`permissionMode`	❌	Permission-Verhalten
`skills`	❌	Skills die geladen werden
`hooks`	❌	Lifecycle Hooks

Hook-Events für Subagents

In Subagent Frontmatter:

PreToolUse - Vor Tool-Nutzung
PostToolUse - Nach Tool-Nutzung
Stop - Wenn Subagent fertig

In settings.json (Main Session):

SubagentStart - Subagent startet (mit matcher für Agent-Name)
SubagentStop - Subagent beendet

Subagent Transcripts

~/.claude/projects/{project}/{sessionId}/subagents/agent-{agentId}.jsonl

Wichtig für uns: Diese Transcripts enthalten das KOMPLETTE Subagent-Gespräch!

CLI-Agnostisches Agent-Tracking

Generisches Agent-Modell

interface UniversalAgent {
  // Identifikation
  id: string;
  name: string;
  type: 'builtin' | 'custom' | 'plugin';
  
  // Konfiguration (falls custom)
  config?: {
    description?: string;
    tools?: string[];
    disallowedTools?: string[];
    model?: 'sonnet' | 'opus' | 'haiku' | 'inherit';
    permissionMode?: 'default' | 'acceptEdits' | 'dontAsk' | 'bypassPermissions' | 'plan';
    skills?: string[];
    systemPrompt?: string;
  };
  
  // Source-Agnostic
  source: 'claude-code' | 'cursor' | 'aider' | 'copilot' | 'custom';
}

interface AgentExecution {
  id: string;
  agentId: string;
  agentName: string;
  agentType: string;  // "Explore", "Plan", "custom-name"
  
  // Lifecycle
  status: 'running' | 'completed' | 'failed' | 'blocked';
  startedAt: Date;
  completedAt?: Date;
  
  // Kontext
  sessionId: string;
  parentSessionId?: string;  // Falls nested
  transcriptPath?: string;
  
  // Execution Details
  thoroughness?: 'quick' | 'medium' | 'very_thorough';  // Für Explore
  foreground: boolean;
  
  // Ergebnis
  result?: string;
  error?: string;
  
  // Metriken
  tokensUsed?: number;
  durationMs?: number;
  toolCallCount?: number;
}

Mapping für verschiedene CLIs

const CLI_AGENT_MAPPING = {
  'claude-code': {
    builtinAgents: ['Explore', 'Plan', 'general-purpose', 'Bash', 'statusline-setup', 'claude-code-guide'],
    customAgentPaths: ['.claude/agents/', '~/.claude/agents/'],
    transcriptFormat: 'jsonl',
  },
  
  'cursor': {
    builtinAgents: ['plan-mode', 'agent-mode'],
    customAgentPaths: ['.cursor/agents/'],  // hypothetisch
    transcriptFormat: 'markdown',
  },
  
  'aider': {
    builtinAgents: ['architect', 'code'],
    modes: ['/mode architect', '/mode code'],
    transcriptFormat: 'chat-history',
  },
  
  'copilot': {
    builtinAgents: ['planner', 'implementer'],
    workspaceFormat: 'spec → plan → implement',
    transcriptFormat: 'markdown',
  },
};

Datenerfassung erweitern

Für Claude Code:

SubagentStart erfassen:

interface SubagentStartEvent {
  agent_id: string;
  agent_type: string;  // "Explore", "Plan", "my-custom-agent"
  session_id: string;
  cwd: string;
  permission_mode: string;
}

SubagentStop erfassen:

interface SubagentStopEvent {
  agent_id: string;
  agent_transcript_path: string;  // Wichtig: Vollständiges Transcript!
  stop_hook_active: boolean;
}

Transcript parsen:

agent_transcript_path enthält JSONL mit allen Tool-Calls
Daraus können wir: Tasks, Ergebnisse, Token-Usage extrahieren

Für andere CLIs (Adapter-Pattern):

interface CLIAdapter {
  name: string;
  
  // Agent-Erkennung
  detectAgents(): Promise<UniversalAgent[]>;
  
  // Event-Streaming
  onAgentStart(callback: (event: AgentExecution) => void): void;
  onAgentStop(callback: (event: AgentExecution) => void): void;
  
  // Transcript-Parsing
  parseTranscript(path: string): Promise<AgentTranscript>;
}

UI-Anforderungen für Agent-Tracking

Agent-Übersicht

┌─────────────────────────────────────────────────────────────┐
│  Agents                                    [Refresh] [+Neu] │
├─────────────────────────────────────────────────────────────┤
│  Built-in                                                   │
│  ├─ 🔍 Explore (Haiku)         Read-only codebase search    │
│  ├─ 📋 Plan (Inherit)          Research für Plans           │
│  ├─ ⚡ general-purpose          Multi-step Tasks            │
│  └─ 💻 Bash                     Terminal-Befehle            │
│                                                             │
│  Custom (Projekt)                                           │
│  ├─ 🔧 code-reviewer           Code Quality Analysis        │
│  └─ 🐛 debugger                Bug-Hunting                  │
│                                                             │
│  Custom (User)                                              │
│  └─ 📊 data-scientist          SQL & BigQuery               │
└─────────────────────────────────────────────────────────────┘

Agent-Execution Timeline

┌─────────────────────────────────────────────────────────────┐
│  Session: abc123                                            │
├─────────────────────────────────────────────────────────────┤
│  10:15  🔍 Explore (quick)                    ✅ 1.2s       │
│         └─ "Find authentication files"                      │
│                                                             │
│  10:16  📋 Plan                               ✅ 3.4s       │
│         └─ "Research API structure"                         │
│         └─ 5 files analyzed, 12 tool calls                  │
│                                                             │
│  10:18  🔧 code-reviewer (custom)             🔄 running    │
│         └─ "Review auth changes"                            │
│         └─ 3/7 files reviewed...                           │
└─────────────────────────────────────────────────────────────┘

Referenzen

## Ergänzende Recherche: Subagents & Custom Agents ### Claude Code Built-in Subagents | Agent | Model | Tools | Zweck | |-------|-------|-------|-------| | **Explore** | Haiku (schnell) | Read-only (kein Write/Edit) | Codebase durchsuchen, Dateien finden | | **Plan** | Inherits | Read-only | Research für Plan-Mode | | **general-purpose** | Inherits | Alle Tools | Komplexe Multi-Step Tasks | | **Bash** | Inherits | Bash | Terminal-Befehle in separatem Kontext | | **statusline-setup** | Sonnet | - | `/statusline` Konfiguration | | **claude-code-guide** | Haiku | - | Fragen zu Claude Code Features | **Quelle:** [Claude Code Subagents Docs](https://code.claude.com/docs/en/sub-agents) ### Explore Agent Details - **Thoroughness Levels:** `quick` | `medium` | `very thorough` - **Zweck:** Exploration aus Main-Conversation raushalten (Context schonen) - **Wichtig:** Subagents können KEINE anderen Subagents spawnen ### Custom Subagent Erstellung **Speicherorte (Priorität):** | Location | Scope | Priorität | |----------|-------|-----------| | `--agents` CLI Flag | Aktuelle Session | 1 (höchste) | | `.claude/agents/` | Projekt | 2 | | `~/.claude/agents/` | Alle Projekte | 3 | | Plugin `agents/` | Plugin-Scope | 4 (niedrigste) | **Subagent Markdown-Format:** ```markdown --- name: code-reviewer description: Reviews code for quality and best practices tools: Read, Glob, Grep disallowedTools: Write, Edit model: sonnet # oder: inherit, opus, haiku permissionMode: default # oder: acceptEdits, dontAsk, bypassPermissions, plan skills: - api-conventions hooks: PreToolUse: - matcher: "Bash" hooks: - type: command command: "./scripts/validate.sh" --- You are a code reviewer. When invoked, analyze the code... ``` ### Verfügbare Frontmatter-Felder | Feld | Required | Beschreibung | |------|----------|--------------| | `name` | ✅ | Eindeutiger Identifier (lowercase, hyphens) | | `description` | ✅ | Wann Claude delegieren soll | | `tools` | ❌ | Erlaubte Tools (Allowlist) | | `disallowedTools` | ❌ | Verbotene Tools (Denylist) | | `model` | ❌ | `sonnet`, `opus`, `haiku`, `inherit` | | `permissionMode` | ❌ | Permission-Verhalten | | `skills` | ❌ | Skills die geladen werden | | `hooks` | ❌ | Lifecycle Hooks | ### Hook-Events für Subagents **In Subagent Frontmatter:** - `PreToolUse` - Vor Tool-Nutzung - `PostToolUse` - Nach Tool-Nutzung - `Stop` - Wenn Subagent fertig **In settings.json (Main Session):** - `SubagentStart` - Subagent startet (mit `matcher` für Agent-Name) - `SubagentStop` - Subagent beendet ### Subagent Transcripts ``` ~/.claude/projects/{project}/{sessionId}/subagents/agent-{agentId}.jsonl ``` **Wichtig für uns:** Diese Transcripts enthalten das KOMPLETTE Subagent-Gespräch! --- ## CLI-Agnostisches Agent-Tracking ### Generisches Agent-Modell ```typescript interface UniversalAgent { // Identifikation id: string; name: string; type: 'builtin' | 'custom' | 'plugin'; // Konfiguration (falls custom) config?: { description?: string; tools?: string[]; disallowedTools?: string[]; model?: 'sonnet' | 'opus' | 'haiku' | 'inherit'; permissionMode?: 'default' | 'acceptEdits' | 'dontAsk' | 'bypassPermissions' | 'plan'; skills?: string[]; systemPrompt?: string; }; // Source-Agnostic source: 'claude-code' | 'cursor' | 'aider' | 'copilot' | 'custom'; } interface AgentExecution { id: string; agentId: string; agentName: string; agentType: string; // "Explore", "Plan", "custom-name" // Lifecycle status: 'running' | 'completed' | 'failed' | 'blocked'; startedAt: Date; completedAt?: Date; // Kontext sessionId: string; parentSessionId?: string; // Falls nested transcriptPath?: string; // Execution Details thoroughness?: 'quick' | 'medium' | 'very_thorough'; // Für Explore foreground: boolean; // Ergebnis result?: string; error?: string; // Metriken tokensUsed?: number; durationMs?: number; toolCallCount?: number; } ``` ### Mapping für verschiedene CLIs ```typescript const CLI_AGENT_MAPPING = { 'claude-code': { builtinAgents: ['Explore', 'Plan', 'general-purpose', 'Bash', 'statusline-setup', 'claude-code-guide'], customAgentPaths: ['.claude/agents/', '~/.claude/agents/'], transcriptFormat: 'jsonl', }, 'cursor': { builtinAgents: ['plan-mode', 'agent-mode'], customAgentPaths: ['.cursor/agents/'], // hypothetisch transcriptFormat: 'markdown', }, 'aider': { builtinAgents: ['architect', 'code'], modes: ['/mode architect', '/mode code'], transcriptFormat: 'chat-history', }, 'copilot': { builtinAgents: ['planner', 'implementer'], workspaceFormat: 'spec → plan → implement', transcriptFormat: 'markdown', }, }; ``` ### Datenerfassung erweitern **Für Claude Code:** 1. **SubagentStart erfassen:** ```typescript interface SubagentStartEvent { agent_id: string; agent_type: string; // "Explore", "Plan", "my-custom-agent" session_id: string; cwd: string; permission_mode: string; } ``` 2. **SubagentStop erfassen:** ```typescript interface SubagentStopEvent { agent_id: string; agent_transcript_path: string; // Wichtig: Vollständiges Transcript! stop_hook_active: boolean; } ``` 3. **Transcript parsen:** - `agent_transcript_path` enthält JSONL mit allen Tool-Calls - Daraus können wir: Tasks, Ergebnisse, Token-Usage extrahieren **Für andere CLIs (Adapter-Pattern):** ```typescript interface CLIAdapter { name: string; // Agent-Erkennung detectAgents(): Promise<UniversalAgent[]>; // Event-Streaming onAgentStart(callback: (event: AgentExecution) => void): void; onAgentStop(callback: (event: AgentExecution) => void): void; // Transcript-Parsing parseTranscript(path: string): Promise<AgentTranscript>; } ``` --- ## UI-Anforderungen für Agent-Tracking ### Agent-Übersicht ``` ┌─────────────────────────────────────────────────────────────┐ │ Agents [Refresh] [+Neu] │ ├─────────────────────────────────────────────────────────────┤ │ Built-in │ │ ├─ 🔍 Explore (Haiku) Read-only codebase search │ │ ├─ 📋 Plan (Inherit) Research für Plans │ │ ├─ ⚡ general-purpose Multi-step Tasks │ │ └─ 💻 Bash Terminal-Befehle │ │ │ │ Custom (Projekt) │ │ ├─ 🔧 code-reviewer Code Quality Analysis │ │ └─ 🐛 debugger Bug-Hunting │ │ │ │ Custom (User) │ │ └─ 📊 data-scientist SQL & BigQuery │ └─────────────────────────────────────────────────────────────┘ ``` ### Agent-Execution Timeline ``` ┌─────────────────────────────────────────────────────────────┐ │ Session: abc123 │ ├─────────────────────────────────────────────────────────────┤ │ 10:15 🔍 Explore (quick) ✅ 1.2s │ │ └─ "Find authentication files" │ │ │ │ 10:16 📋 Plan ✅ 3.4s │ │ └─ "Research API structure" │ │ └─ 5 files analyzed, 12 tool calls │ │ │ │ 10:18 🔧 code-reviewer (custom) 🔄 running │ │ └─ "Review auth changes" │ │ └─ 3/7 files reviewed... │ └─────────────────────────────────────────────────────────────┘ ``` --- ## Referenzen - [Claude Code Subagents Docs](https://code.claude.com/docs/en/sub-agents) - [Claude Code System Prompts Repository](https://github.com/Piebald-AI/claude-code-system-prompts) - [Awesome Claude Code Subagents (100+ Examples)](https://github.com/VoltAgent/awesome-claude-code-subagents) - [Claude Code Customization Guide](https://alexop.dev/posts/claude-code-customization-guide-claudemd-skills-subagents/)

jack commented

2026-01-25 11:11:03 +00:00

Author

Owner

Design-Constraint: WebUI greift nicht in CLI ein

Grundregel

Der User darf über das WebUI NICHT in CLI-Prozesse eingreifen:

❌ Task-Status ändern (pending → completed)
❌ Drag & Drop im Kanban
❌ Tasks manuell erstellen/bearbeiten
❌ Plan-Hierarchien ändern
❌ Agents steuern

Warum?

Tasks, Plans und Agents sind CLI-Events - sie werden ausschließlich durch Hooks erfasst und aktualisiert. Das WebUI ist eine Monitoring-Ansicht, kein Task-Management-Tool.

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   Claude Code   │────▶│     Hooks       │────▶│    Backend      │
│   (oder andere  │     │  (Events)       │     │    (DB)         │
│    CLIs)        │     │                 │     │                 │
└─────────────────┘     └─────────────────┘     └─────────────────┘
                                                        │
                                                        ▼
                                                ┌─────────────────┐
                                                │     WebUI       │
                                                │  (Read-Only)    │
                                                │                 │
                                                │ - Tasks ansehen │
                                                │ - Status sehen  │
                                                │ - KEINE Edits   │
                                                └─────────────────┘

UI-Konsequenzen

Kanban-Board:

Nur Visualisierung, kein Drag & Drop
Status-Spalten zeigen aktuellen Stand
Keine Interaktion außer Klick zum Ansehen

Task-Liste:

Nur lesen, nicht bearbeiten
Filter und Suche erlaubt
Keine Checkboxen zum Abhaken

Task-Detail:

Read-only Ansicht
Zeigt: Status, Beschreibung, Agent, Session, Timestamps
Keine Edit-Buttons

Zusammenfassung: Das WebUI zeigt Tasks/Plans/Agents an, ändert sie aber nie. Alle Änderungen kommen ausschließlich von CLI-Hooks.

## Design-Constraint: WebUI greift nicht in CLI ein ### Grundregel **Der User darf über das WebUI NICHT in CLI-Prozesse eingreifen:** - ❌ Task-Status ändern (pending → completed) - ❌ Drag & Drop im Kanban - ❌ Tasks manuell erstellen/bearbeiten - ❌ Plan-Hierarchien ändern - ❌ Agents steuern ### Warum? Tasks, Plans und Agents sind **CLI-Events** - sie werden ausschließlich durch Hooks erfasst und aktualisiert. Das WebUI ist eine **Monitoring-Ansicht**, kein Task-Management-Tool. ``` ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Claude Code │────▶│ Hooks │────▶│ Backend │ │ (oder andere │ │ (Events) │ │ (DB) │ │ CLIs) │ │ │ │ │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ ▼ ┌─────────────────┐ │ WebUI │ │ (Read-Only) │ │ │ │ - Tasks ansehen │ │ - Status sehen │ │ - KEINE Edits │ └─────────────────┘ ``` ### UI-Konsequenzen **Kanban-Board:** - Nur Visualisierung, kein Drag & Drop - Status-Spalten zeigen aktuellen Stand - Keine Interaktion außer Klick zum Ansehen **Task-Liste:** - Nur lesen, nicht bearbeiten - Filter und Suche erlaubt - Keine Checkboxen zum Abhaken **Task-Detail:** - Read-only Ansicht - Zeigt: Status, Beschreibung, Agent, Session, Timestamps - Keine Edit-Buttons --- **Zusammenfassung:** Das WebUI zeigt Tasks/Plans/Agents an, ändert sie aber nie. Alle Änderungen kommen ausschließlich von CLI-Hooks.

jack commented

2026-01-25 18:38:07 +00:00

Author

Owner

Implementation Complete ✅

Nach einer umfassenden Exploration zeigt sich, dass dieses Feature bereits vollständig implementiert ist:

Implementierte Komponenten

Phase	Komponente	Status
Phase 1	UserTask Entity	✅ `packages/database/src/entities/UserTask.ts`
	UserTask Repository	✅ `packages/database/src/repositories/UserTaskRepository.ts`
	REST API Endpoints	✅ `/api/hooks/user-task/*`
	WebSocket/SSE Events	✅ `user-task:created`, `user-task:updated`
Phase 2	PostToolUse Hook (TaskCreate)	✅ `packages/hooks/src/handlers/post-tool-use.ts`
	PostToolUse Hook (TaskUpdate)	✅ `packages/hooks/src/handlers/post-tool-use.ts`
Phase 3	UserTasksView	✅ `packages/ui/src/views/UserTasks.tsx`
	Kanban-Board	✅ Status-basierte Spalten
	Listen-Ansicht	✅ Mit Pagination
	Modal-Detail	✅ Vollständige Task-Ansicht
	Export	✅ JSON + Markdown
	Filtering	✅ Status, Source, Project, Priority
	Navigation	✅ Sidebar → "User Tasks"

Claude Code Limitationen

Folgende Punkte sind nicht umsetzbar (keine Claude Code API):

PreToolUse Hook existiert nicht in Claude Code
permission_mode Detection nicht Teil der Standard Hook API

Phase 4 (Optional)

Die erweiterten Features (Bulk-Ops, Templates, Recurring, Notifications) können bei Bedarf als separate Issues erstellt werden.

Closing as implemented.

## Implementation Complete ✅ Nach einer umfassenden Exploration zeigt sich, dass dieses Feature **bereits vollständig implementiert** ist: ### Implementierte Komponenten | Phase | Komponente | Status | |-------|------------|--------| | **Phase 1** | UserTask Entity | ✅ `packages/database/src/entities/UserTask.ts` | | | UserTask Repository | ✅ `packages/database/src/repositories/UserTaskRepository.ts` | | | REST API Endpoints | ✅ `/api/hooks/user-task/*` | | | WebSocket/SSE Events | ✅ `user-task:created`, `user-task:updated` | | **Phase 2** | PostToolUse Hook (TaskCreate) | ✅ `packages/hooks/src/handlers/post-tool-use.ts` | | | PostToolUse Hook (TaskUpdate) | ✅ `packages/hooks/src/handlers/post-tool-use.ts` | | **Phase 3** | UserTasksView | ✅ `packages/ui/src/views/UserTasks.tsx` | | | Kanban-Board | ✅ Status-basierte Spalten | | | Listen-Ansicht | ✅ Mit Pagination | | | Modal-Detail | ✅ Vollständige Task-Ansicht | | | Export | ✅ JSON + Markdown | | | Filtering | ✅ Status, Source, Project, Priority | | | Navigation | ✅ Sidebar → "User Tasks" | ### Claude Code Limitationen Folgende Punkte sind **nicht umsetzbar** (keine Claude Code API): - `PreToolUse` Hook existiert nicht in Claude Code - `permission_mode` Detection nicht Teil der Standard Hook API ### Phase 4 (Optional) Die erweiterten Features (Bulk-Ops, Templates, Recurring, Notifications) können bei Bedarf als separate Issues erstellt werden. --- **Closing as implemented.**

jack closed this issue

2026-01-25 18:38:08 +00:00

jack referenced this issue

2026-01-25 19:17:34 +00:00

bug: UserTask nicht gespeichert - TaskCreate Hook erfasst taskId nicht aus toolOutput #316

jack referenced this issue

2026-01-25 19:21:01 +00:00

feat: PlanMode-Status auf Session tracken (EnterPlanMode/ExitPlanMode) #317