[FEATURE] Dry-run/simulation mode for Cowork tasks

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Cowork currently operates with a step-by-step approval model where Claude shows its plan and waits for user approval before significant actions. While this provides some control, it does not allow users to validate the complete end state of a task before any changes occur.
The core problem: There is no way to see what Cowork will produce without actually producing it.
Current workflow limitations

Incremental visibility only - Users see Claude's reasoning and approach step-by-step, but cannot evaluate the full scope of changes until execution is complete.
No rollback mechanism - Once files are created, modified, or deleted, reverting requires manual intervention or reliance on external backup/version control.
Validation requires execution - To determine if an agent task is configured correctly, users must run it against real files. This is problematic for:

Complex multi-step tasks where early errors propagate
Tasks involving large file sets where partial execution creates inconsistent states
Production folders where unintended changes have business impact
Recurring/scheduled tasks that need validation before going live

Testing against copies is cumbersome - The current workaround is to duplicate the target folder, run Cowork against the copy, validate results, then either use those results or re-run against the original. This doubles execution time and token consumption, and still doesn't guarantee identical behavior on the second run.

Real-world scenarios where this causes friction

Scenario 1: File reorganization
User asks Cowork to reorganize 500 files across nested directories by content type and date. User wants to verify the proposed directory structure and file placements before any moves occur. Currently impossible without full execution.

Scenario 2: Batch document generation
User asks Cowork to generate 20 expense reports from receipt images. User wants to verify the output format, naming convention, and content extraction logic on a representative sample before committing to the full batch. Currently requires running the full task or manually limiting scope.

Scenario 3: Scheduled task validation
User configures a recurring task to run daily (e.g., organize downloads, generate summaries). User wants to validate the task logic will behave correctly across different input states before enabling the schedule. Currently requires either live execution or waiting for the schedule to trigger and observing results.

Scenario 4: Multi-connector workflows
User asks Cowork to pull data from external connectors, process it, and write output files. User wants to verify the full data flow and output structure before any files are written or external actions taken. Currently the only option is to let it run and review after the fact.

Proposed Solution

Implement a dry-run or simulation mode that:

Executes the full task logic - Claude plans and reasons through the complete task as it would in normal mode.
Generates all intended outputs in a preview state - Files that would be created are generated but held in a staging area (temp directory, preview pane, or diff view) rather than written to the target location.
Reports all intended file operations - A manifest showing:

Files to be created (with preview of content or summary)
Files to be modified (with diff view)
Files to be deleted (with confirmation list)
Files to be moved/renamed (with source and destination paths)

Allows user review before commit - User reviews the complete end state and either:

Approves: All staged changes are committed to the target location
Rejects: All staged changes are discarded, no modifications occur
Modifies: User provides feedback, Claude revises the plan, and a new dry-run executes

Supports partial approval (optional enhancement) - User can approve some operations and reject others from the manifest.

UI/UX considerations

Dry-run mode could be triggered via:

A toggle in the Cowork interface ("Preview before executing")
A slash command (/dryrun or /preview)
A global or folder-level setting for users who always want preview mode

Preview output could be displayed as:

A file tree showing proposed structure with indicators for new/modified/deleted
A scrollable manifest with expandable details per file
Side-by-side diff views for modifications

Alternative Solutions

Manual folder duplication - Works but doubles time/cost, doesn't guarantee identical second-run behavior, and is not viable for connector-based tasks.
More granular step-by-step approval - Increases user friction without solving the core problem of not seeing the end state.
Undo/rollback functionality - Useful but reactive rather than preventive; doesn't help users who want to validate before any changes occur.

Priority

Critical - Blocking my work

Feature Category

CLI commands and flags

Use Case Example

User asks Cowork to clean up a project folder by:

Moving completed deliverables to an archive directory
Deleting temporary files, duplicates, and outdated drafts
Restructuring remaining files into a new folder hierarchy

Before any files are moved or deleted, the user needs to:

Confirm no critical files are incorrectly flagged for deletion
Verify move destinations are correct
Review the proposed folder structure

Currently, the user must either let Cowork execute against live files (risking unintended deletions or misplacements) or manually duplicate the entire folder structure first, validate results, and then repeat the operation against the original. There is no way to see the complete list of planned moves and deletions, review the post-operation state, and approve or reject the batch before any filesystem changes occur.

Additional Context

This feature aligns with enterprise use cases where change control and pre-validation are standard practice.
Similar functionality exists in other tools: Git's --dry-run flag, rsync's -n option, Terraform's plan command, Ansible's --check mode.
Cowork's research preview status makes this an appropriate time to establish safe-by-default patterns before broader adoption.