home / skills / openclaw / skills / task-status

task-status skill

/skills/mightyprime1/task-status

This skill provides automated and manual status updates for long-running tasks, with 5-second heartbeat monitoring and consistent reporting templates.

npx playbooks add skill openclaw/skills --skill task-status

Review the files below or copy the command above to add this skill to your agents.

Files (9)
SKILL.md
4.3 KB
---
name: task-status
description: Send short status descriptions in chat for long-running tasks. Use when you need to provide periodic updates during multi-step operations, confirm task completion, or notify of failures. Includes automated periodic monitoring that sends updates every 5 seconds, status message templates, and a helper function for consistent status reporting.
---

# Task Status Skill

## Quick Start

### Manual Status Updates
```bash
python scripts/send_status.py "Starting data fetch..." "progress" "step1"
python scripts/send_status.py "Processing complete" "success" "final"
python scripts/send_status.py "Error: Missing API key" "error" "auth"
```

### Automatic Periodic Monitoring (Every 5 seconds)
```bash
# Start monitoring a long-running task
python scripts/monitor_task.py start "My Long Task" "processing"

# Monitor will send "Still working..." updates every 5 seconds
# When task completes, report final status
python scripts/monitor_task.py stop "My Long Task" "success" "Completed successfully!"
```

## Status Types

- **progress**: Ongoing work (shows 🔄 or ->)
- **success**: Task complete (shows ✅ or OK)
- **error**: Failed task (shows ❌ or !)
- **warning**: Issue but continuing (shows ⚠️ or ?)

## Periodic Monitoring

The `monitor_task.py` script provides automatic updates:

### Starting Monitor
```bash
python scripts/monitor_task.py start "<task_name>" "<status_type>" [--interval <seconds>]
```

- Automatically sends "Still working..." updates every 5 seconds
- Runs in background until stopped
- Can be customized with different intervals

### Stopping Monitor
```bash
python scripts/monitor_task.py stop "<task_name>" "<final_status>" "<final_message>"
```

### Example: Long File Processing
```bash
# Start monitoring
python scripts/monitor_task.py start "video_processing" "progress"

# ... long processing happens here ...

# Stop with final status
python scripts/monitor_task.py stop "video_processing" "success" "Processing complete!"
```

## Manual Updates (Quick Status)

For single status updates without monitoring:

```bash
python scripts/send_status.py "Still fetching data..." "progress" "fetch"
python scripts/send_status.py "Processing records: 250/1000" "progress" "process"
python scripts/send_status.py "Complete! 3 files ready" "success" "final"
python scripts/send_status.py "Error: Connection timeout" "error" "api"
```

## When to Use Each Method

### Use Manual Updates When:
- Task is short (under 30 seconds)
- You want control over when updates are sent
- Task has discrete, meaningful milestones

### Use Periodic Monitoring When:
- Task is long-running (over 1 minute)
- You want consistent "heartbeat" updates every 5 seconds
- Task has long periods of quiet work
- You want to reassure user that work is ongoing

## Message Guidelines

Keep status messages under 140 characters. Examples:

- **Progress**: "Still fetching data..." or "Processing records: 250/1000"
- **Success**: "Complete! 3 files ready" or "Task finished successfully"
- **Error**: "Error: Connection timeout" or "Failed: Missing API key"
- **Warning**: "Continuing despite timeout" or "Partial success: 5/10 files"

## Advanced Usage

### With Additional Details
```bash
python scripts/send_status.py "Uploading..." "progress" "upload" --details "File: report.pdf (2.4MB)"
```

### Different Intervals
```bash
python scripts/monitor_task.py start "data_sync" "progress" --interval 10
```

### Importing for Python Scripts
```python
from send_status import send_status

def long_task():
    send_status("Starting...", "progress", "step1")
    # ... work
    send_status("Step complete", "success", "step1")
```

## Automation with Clawdbot Cron

For scheduled tasks, use Clawdbot's cron feature:

```python
# In a script or session
from cron import add

# Every 5 seconds, check status
job = {
    "text": "Check status update",
    "interval": "5s",
    "enabled": True
}
add(job)
```

This allows status updates even when you're not actively watching.

## Installation

To use this skill, copy the `task-status` folder into your Clawdbot skills directory:

```
C:\Users\Luffy\AppData\Roaming\npm\node_modules\clawdbot\skills\task-status
```

Or add it to your workspace and reference it from `AGENTS.md` or `TOOLS.md`.

Once installed, the skill will be available for any task where you need periodic status updates.

Overview

This skill sends short, consistent status messages in chat for long-running or multi-step tasks. It provides manual one-off updates, automated periodic monitoring (default every 5 seconds), and a helper function to keep reporting uniform across scripts. Use it to reassure users, confirm completion, or report failures with minimal overhead.

How this skill works

You can call a send_status helper for single updates or run a monitor that emits a heartbeat message at a configured interval. The monitor runs in the background until stopped and then posts a final status. Status types (progress, success, error, warning) map to clear icons and concise templates to keep messages under 140 characters.

When to use it

  • Provide periodic ‘still working’ heartbeats for long-running tasks (over 1 minute).
  • Report discrete milestones or results for short tasks (under 30 seconds).
  • Confirm task completion or final outcome to downstream systems or users.
  • Notify immediately when an error or warning occurs during processing.
  • Integrate into scheduled jobs or cron-driven pipelines for automated reporting.

Best practices

  • Keep messages under 140 characters and focus on outcome or next step.
  • Use predefined status types (progress, success, error, warning) for consistent UX.
  • Start the monitor at task start and stop it with a final status to avoid orphaned background jobs.
  • Prefer manual updates for meaningful milestones and monitoring for quiet, long operations.
  • Include minimal details or an identifier (task name or step id) so messages are actionable.

Example use cases

  • Start monitoring video transcoding and send a final success when files are ready.
  • Send periodic updates during large data imports to reassure users that work is ongoing.
  • Post a short error immediately when an API key or connection problem occurs.
  • Use in scheduled backup jobs to emit heartbeats every 5 seconds and a final status when done.
  • Embed send_status in Python scripts to annotate multi-step pipelines with concise progress and completion notes.

FAQ

How often does the automated monitor send updates?

Default interval is 5 seconds, configurable per monitor instance.

What status types are supported and when should I use each?

Use progress for ongoing work, success for completion, error for failures, and warning for issues that allow continuation.