[Mobile Feature Request] Live progress, subtasks, pause/replay, conflict analysis, and duplicate-thread protection for GitHub tasks

What variant of Codex are you using?

Web / ChatGPT Android app with GitHub integration

What feature would you like to see?

Title

[Mobile Feature Request] Live progress, subtasks, pause/replay, conflict analysis, and duplicate-thread protection for GitHub tasks

What variant of Codex are you using?

Web / ChatGPT Android app with GitHub integration

What feature would you like to see?

I would like a mobile-first task control panel for long-running Codex GitHub tasks.

When I start a repository task from the ChatGPT Android app, I often cannot understand whether the task is still running, stalled, interrupted, waiting for input, or already completed. This makes me repeatedly message the same thread or accidentally start a duplicate task.

The panel should include:

1. Live progress bar

Show:

confirmed completion percentage;

estimated completion percentage;

completed and total subtasks;

current stage;

elapsed time;

latest meaningful activity;

approximate remaining time;

confidence level of the estimate.

The percentage should be based on completed and verified subtasks rather than elapsed time.

If Codex discovers more work, it should explain why the percentage changed.

Example:

Three additional dependencies were discovered.The plan increased from 8 to 11 subtasks.Progress was recalculated from 62% to 48%.

1. Subtask decomposition panel

Show a collapsible list of:

completed subtasks;

active subtask;

pending subtasks;

blocked subtasks;

newly discovered subtasks;

cancelled subtasks and reasons.

Example:

✅ Repository analysis

✅ Bug reproduction

✅ Implementation plan

🔄 Updating frontend

⏳ Running automated tests

⏳ Reviewing changes

⏳ Creating pull request

1. Real-time “Before → Changed → Current” analytics

Show:

what existed before the task;

what Codex changed;

the current verified state;

files changed;

tests before and after;

errors found and resolved;

active blockers;

newly introduced risks;

conflicts detected.

This information should be optimized for a small mobile screen and expandable when more detail is needed.

1. Safe pause and resume

Provide mobile controls for:

Pause safely;

Resume;

Stop safely;

Roll back to checkpoint.

Before pausing, Codex should save a checkpoint containing:

task objective;

current plan;

completed subtasks;

file changes;

test results;

blockers;

repository state;

next expected action.

The task should resume without repeating completed work.

1. Replayable process timeline

Allow the user to replay observable task events, such as:

repository inspected;

task decomposed;

related threads found;

bug reproduced;

files changed;

tests executed;

failures discovered;

conflicts detected;

checkpoint saved;

commit or pull request created.

Replay should show observable actions and artifacts, not hidden internal reasoning.

Suggested filters:

All activity;

Code changes only;

Tests only;

Errors and conflicts only;

User decisions only.

1. Conflict analysis

Show a dedicated conflict-analysis panel for conflicts between:

branches;

pull requests;

simultaneous agent tasks;

duplicate conversation threads;

old and new user instructions;

dependency versions;

overlapping file changes.

For each conflict, show:

affected file, branch, task, or instruction;

probable cause;

risk level;

proposed resolution;

affected tests;

whether automatic resolution is safe;

current resolution status.

High-risk resolutions should require user approval.

1. Duplicate-thread detection

Before starting a new GitHub task, Codex should detect similar active conversations based on:

repository;

branch;

issue or pull request;

affected files;

task objective;

expected result.

Example:

A similar GitHub task is already active with an estimated 87% match.

Actions:

Open existing task;

Add the instruction to the active task;

Merge task contexts;

Mark the older task as superseded;

Start a separate task anyway.

1. Mobile background visibility

When the phone is locked or ChatGPT is minimized, the user should be able to see the task through:

an in-app Active Tasks screen;

Android notifications;

task-completed notifications;

blocked-task notifications;

user-input-required notifications.

The interface should clearly state whether the task continues on the server and whether the app can be safely closed.

1. Related-thread resolution and context compaction

After the main task is completed, related duplicate threads could be:

linked to the resulting pull request or commit;

marked as resolved;

archived;

marked as superseded;

merged into one source-of-truth task.

Before reducing duplicated context, Codex should save a durable task summary with:

objective;

decisions;

completed work;

files changed;

test results;

remaining risks;

related commits and pull requests;

next actions.

Automatic closure should be configurable to avoid false-positive duplicate detection.

Additional information

This request is specifically motivated by working with Codex and GitHub from a mobile phone.

On mobile, the user may lock the screen, switch applications, temporarily lose connection, or return to the task later. Without persistent progress visibility, it is difficult to know whether Codex is still working.

The expected result is that a mobile user can always answer:

Is the task still active?

What percentage is complete?

What has already been completed?

What is happening now?

What remains?

Is anything blocked?

Is another conversation already doing the same work?

Can the app be safely closed?

Has the task state been checkpointed?

This could reduce duplicate work, conflicting repository changes, unnecessary user messages, wasted context, and uncertainty during long-running GitHub tasks.

Additional information

_No response_