# कार्य-संचालित वर्कफ़्लो

Tasks सिर्फ todos नहीं हैं — वे परसिस्टेंट LLM वर्कफ़्लो की रीढ़ हैं। मल्टी-स्टेप कार्य के लिए tasks बनाकर, आप सत्रों में निरंतरता सुनिश्चित करते हैं और जो काम किया गया उसके लिए ऑडिट ट्रेल प्रदान करते हैं।

## कार्य-संचालित क्यों?

Tasks के बिना:
- LLM हर सत्र की शुरुआत में अनिश्चित होता है कि क्या करना है
- मल्टी-स्टेप कार्य निष्पादन के बीच भूल जाते हैं
- क्या किया गया इसका कोई रिकॉर्ड नहीं

Tasks के साथ:
- LLM तुरंत प्रगति में कार्य फिर से शुरू करता है
- मल्टी-स्टेप कार्य सत्रों में जीवित रहते हैं
- सभी कार्य का इन-बिल्ट ऑडिट ट्रेल

## पैटर्न

```
1. At session start: check in_progress tasks
2. If tasks exist: resume them
3. If no tasks: create new tasks for current work
4. Update task status as you progress
5. Mark done when complete
```

## कार्यान्वयन

### चरण 1: मल्टी-स्टेप कार्य के लिए task बनाएँ

```python
def start_workflow(title, steps):
    """Create a task for multi-step work."""
    task_id = create_task(
        title=title,
        description=f"Steps:\n" + "\n".join(f"  {i+1}. {s}" for i, s in enumerate(steps)),
        priority="high"
    )
    return task_id

# Example
task_id = start_workflow("Deploy Synapse v1.6.0", [
    "Bump version in package.json",
    "Update CHANGELOG.md",
    "Commit and push",
    "Wait for CI green",
    "Verify deployment"
])
```

### चरण 2: task विवरण में प्रगति ट्रैक करें

```python
def update_progress(task_id, current_step, total_steps, status_note):
    """Update task with current progress."""
    description = f"Progress: {current_step}/{total_steps}\nStatus: {status_note}"
    update_task(task_id, status="in_progress", description=description)

# Example
update_progress(task_id, 2, 5, "CHANGELOG updated, committing now")
```

### चरण 3: सत्रों में फिर से शुरू करें

```python
def resume_work():
    """At session start, find and resume in-progress tasks."""
    tasks = list_tasks(status="in_progress")
    
    for task in tasks:
        print(f"Resuming: {task['title']}")
        print(f"Last status: {task['description']}")
        
        # Parse progress from description
        progress = parse_progress(task['description'])
        next_step = progress['current_step'] + 1
        
        # Continue from next step
        continue_from_step(task['id'], next_step)
```

### चरण 4: पूर्ण करें और संग्रहित करें

```python
def complete_task(task_id, summary):
    """Mark task done with completion summary."""
    update_task(task_id, 
        status="done",
        description=f"COMPLETED. Summary: {summary}"
    )
    # Also store as memory for long-term reference
    remember(
        category="project",
        key=f"completed_{task_id}",
        content=f"Task: {task_id}\nSummary: {summary}",
        tags=["completed", "task"],
        priority="normal"
    )
```

## पूर्ण उदाहरण: डिप्लॉय वर्कफ़्लो

```python
class DeployWorkflow:
    def __init__(self, version):
        self.version = version
        self.task_id = None
        self.steps = [
            ("Bump version", self.bump_version),
            ("Update changelog", self.update_changelog),
            ("Commit and push", self.commit_push),
            ("Wait for CI", self.wait_for_ci),
            ("Verify deployment", self.verify_deployment),
        ]
    
    def run(self):
        # Check if already in progress
        existing = self.find_existing()
        if existing:
            self.task_id = existing['id']
            start_step = self.parse_progress(existing['description'])
        else:
            self.task_id = create_task(
                title=f"Deploy Synapse v{self.version}",
                description=self.build_description(0),
                priority="high"
            )
            start_step = 0
        
        # Execute remaining steps
        for i in range(start_step, len(self.steps)):
            step_name, step_fn = self.steps[i]
            self.update_progress(i, f"Running: {step_name}")
            try:
                step_fn()
            except Exception as e:
                self.update_progress(i, f"FAILED at {step_name}: {e}")
                raise
        
        self.complete()
    
    def update_progress(self, step_idx, status):
        update_task(self.task_id,
            status="in_progress",
            description=f"Step {step_idx+1}/{len(self.steps)}: {status}"
        )
    
    def complete(self):
        complete_task(self.task_id, f"Deployed v{self.version} successfully")
```

## कार्य पदानुक्रम

जटिल कार्य के लिए, parent-child कार्य संबंधों का उपयोग करें:

```python
# Parent task
parent_id = create_task("v1.6.0 Release", priority="high")

# Sub-tasks (linked via tags)
create_task("Bump version", 
    description=f"Parent: {parent_id}",
    tags=["v1.6.0", f"parent-{parent_id}"],
    priority="high")

create_task("Update docs",
    description=f"Parent: {parent_id}",
    tags=["v1.6.0", f"parent-{parent_id}"],
    priority="normal")
```

उप-कार्यों के लिए खोजें:

```bash
curl -H "Authorization: Bearer $KEY" \
     ".../memory/search?q=parent-{parent_id}&tag=v1.6.0"
```

## स्थिति वर्कफ़्लो

```
pending → in_progress → done
                ↘ cancelled
```

### Pending

कार्य बनाया गया लेकिन शुरू नहीं हुआ। योजित कार्य के लिए उपयोग करें।

### In Progress

वर्तमान में कार्य किया जा रहा है। **प्रगति के साथ विवरण अपडेट करें।**

### Done

सफलतापूर्वक पूर्ण। विवरण में सारांश होना चाहिए।

### Cancelled

त्यागा गया। विवरण में कारण होना चाहिए।

## सर्वोत्तम अभ्यास

> [!TIP]
> - **मल्टी-स्टेप कार्य के लिए tasks बनाएँ** — सिंगल-स्टेप कार्य को task की आवश्यकता नहीं
> - **प्रगति के साथ विवरण अपडेट करें** — फिर से शुरू करना सक्षम बनाता है
> - **सक्रिय कार्य के लिए high प्राथमिकता का उपयोग करें** — रिकॉल में दिखाई देता है
> - **पूर्ण होने पर tasks पूरे करें** — उन्हें in_progress मत छोड़ें
> - **पूर्णता सारांश को मेमोरी के रूप में स्टोर करें** — दीर्घकालिक संदर्भ

## सामान्य पैटर्न

### पैटर्न: बग फिक्स वर्कफ़्लो

```python
def fix_bug(bug_id, description):
    task_id = create_task(
        title=f"Fix bug {bug_id}",
        description=description,
        priority="high"
    )
    
    # Investigate
    update_progress(task_id, "Investigating root cause")
    root_cause = investigate()
    
    # Fix
    update_progress(task_id, f"Applying fix: {root_cause}")
    apply_fix(root_cause)
    
    # Test
    update_progress(task_id, "Testing fix")
    run_tests()
    
    # Deploy
    update_progress(task_id, "Deploying fix")
    deploy()
    
    complete_task(task_id, f"Fixed: {root_cause}")
```

### पैटर्न: रिसर्च वर्कफ़्लो

```python
def research_topic(topic):
    task_id = create_task(
        title=f"Research: {topic}",
        priority="normal"
    )
    
    update_progress(task_id, "Gathering sources")
    sources = gather_sources(topic)
    
    update_progress(task_id, "Analyzing")
    analysis = analyze(sources)
    
    update_progress(task_id, "Storing findings")
    remember("fact", f"research_{topic}", analysis,
             tags=["research", topic], priority="normal")
    
    complete_task(task_id, f"Research complete: {len(sources)} sources")
```

## अगले कदम

- [Session Start Pattern](/docs/llm-cookbook/session-start-pattern)
- [Chat Polling Pattern](/docs/llm-cookbook/chat-polling-pattern)
- [Error Recovery](/docs/llm-cookbook/error-recovery)