Issue Station
Sign In
Tools hereToolbox

openclaw - 💡(How to fix) Fix Feature request: unified background task status dashboard [1 participants]

Official PRs (…)
ON THIS PAGE

Recommended Tools

×6

Utilities matched from this issue’s tags and category — try them while you read without losing context.

GitHub issue graph ai analysis

Paste a GitHub issue URL. We fetch that issue, discover linked issues from bodies/comments/timeline, collect linked pull requests, and produce a structured English report.

The report is written in English Markdown for sharing and archival.

Helpful · Quick feedback

Loading…
GitHub stats
openclaw/openclaw#55493•Fetched 2026-04-08 01:38:52
View on GitHub
Comments
0
Participants
1
Timeline
1
Reactions
0
Author
upsightxupsightx
Participants
upsightxupsightx
Timeline (top)
cross-referenced ×1

OpenClaw already supports async/background work across multiple execution mechanisms:

  • main sessions
  • sub-agents
  • ACP sessions
  • exec/process flows

But status visibility is still fragmented and too low-level.

Operators often have to mentally reconstruct task state from:

  • sessions
  • subagents
  • process logs
  • tool results
  • runtime events

This makes background work technically observable, but not semantically clear.

Root Cause

This would significantly improve:

  • long-running task ergonomics
  • observability
  • trust in async execution
  • operator confidence
  • intervention workflows
  • general system coherence

In short, this helps OpenClaw explain what is happening after work starts.

RAW_BUFFERClick to expand / collapse

Summary

OpenClaw already supports async/background work across multiple execution mechanisms:

  • main sessions
  • sub-agents
  • ACP sessions
  • exec/process flows

But status visibility is still fragmented and too low-level.

Operators often have to mentally reconstruct task state from:

  • sessions
  • subagents
  • process logs
  • tool results
  • runtime events

This makes background work technically observable, but not semantically clear.

Problem

What users and agents actually want to know is:

  • what is this task doing right now?
  • is it blocked?
  • why is it blocked?
  • does it need intervention?
  • is it done and just waiting to be reported?

Right now, too much of that has to be inferred manually.

Proposed direction: unified task-centric status dashboard

Introduce a task-centric status model that is separate from raw sessions/processes.

Suggested per-task fields:

  • task name
  • owner / executor (main, subagent, ACP, process)
  • current phase
  • block reason
  • latest meaningful update
  • suggested next action
  • last update time

Suggested normalized phases

  • queued
  • starting
  • reading_context
  • researching
  • planning
  • editing
  • testing
  • waiting_user
  • waiting_approval
  • waiting_dependency
  • summarizing
  • done
  • failed
  • stalled

Suggested block reasons:

  • waiting for user input
  • waiting for confirmation
  • waiting for approval
  • waiting for OAuth / auth
  • waiting for subagent
  • waiting for external API
  • suspected stall (no heartbeat / no new output)

Important design point

A task should not be treated as identical to a session.

A single user-visible task may span:

  • main session planning
  • one or more sub-agent runs
  • one or more exec processes
  • retries
  • final summarization back in the main session

So the model likely needs:

  • Task = user intent unit
  • Run = one execution attempt
  • Worker = actual runtime/session/process

What this should enable

A useful status dashboard should show:

  • what phase the task is in
  • whether it is blocked or stalled
  • why it is blocked
  • the latest meaningful progress summary
  • whether human/agent intervention is needed
  • whether the task is complete but not yet reported

This is much more useful than raw low-level runtime state.

MVP suggestion

Start with a normalized task event model and a read-only view.

For example, maintain:

  • task id
  • phase
  • summary
  • last update time
  • blocked/stalled detection

Even a simple overview of active tasks would already provide a lot of value.

Why this matters

This would significantly improve:

  • long-running task ergonomics
  • observability
  • trust in async execution
  • operator confidence
  • intervention workflows
  • general system coherence

In short, this helps OpenClaw explain what is happening after work starts.

extent analysis

Fix Plan

To implement a unified task-centric status dashboard, follow these steps:

  • Introduce a Task model with the suggested fields:
    • task name
    • owner / executor
    • current phase
    • block reason
    • latest meaningful update
    • suggested next action
    • last update time
  • Create a Run model to represent one execution attempt
  • Create a Worker model to represent the actual runtime/session/process
  • Develop a task event model to track phase changes, block reasons, and updates
  • Implement a read-only view for the task status dashboard

Example code (Python):

from enum import Enum
from datetime import datetime

class TaskPhase(Enum):
    QUEUED = "queued"
    STARTING = "starting"
    READING_CONTEXT = "reading_context"
    # ...

class Task:
    def __init__(self, task_name, owner):
        self.task_name = task_name
        self.owner = owner
        self.phase = TaskPhase.QUEUED
        self.block_reason = None
        self.latest_update = None
        self.suggested_next_action = None
        self.last_update_time = datetime.now()

class Run:
    def __init__(self, task, worker):
        self.task = task
        self.worker = worker
        self.start_time = datetime.now()

class Worker:
    def __init__(self, worker_id):
        self.worker_id = worker_id

# Example usage:
task = Task("Example Task", "Main Session")
run = Run(task, Worker("Worker 1"))
task.phase = TaskPhase.STARTING
print(task.phase)  # Output: starting

Verification

To verify the fix, check the following:

  • The task status dashboard displays the correct phase, block reason, and latest update for each task
  • The task event model correctly tracks phase changes and updates
  • The read-only view provides a useful overview of active tasks

Extra Tips

  • Consider using a message queue or event bus to handle task events and updates
  • Implement retries and error handling for failed tasks
  • Use a database or data store to persist task data and ensure consistency across multiple workers and sessions.

Vote matrix · Quick signals

Works
Did the solution work? Tap to confirm.
Easy Fix
Was it a quick fix?
Time Saver
Did it save you time?
Blocking
Was it severely blocking?
Common Issue
Are others likely hitting this too?
Flaky / Intermittent
Is it intermittent?
Verified / Reproducible
Can you reproduce it reliably?
Loading…
#api#ssr#model compatibility#GPU setup#container setup

Still need to ship something?

×6

Another batch ranked right after the header list — different links, same matching logic.

Back to top recommendations

TRENDING