claude-code - 💡(How to fix) Fix [FEATURE] Cowork Dispatch: child task sessions should inherit parent's mounted directory [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
anthropics/claude-code#47041Fetched 2026-04-13 05:43:02
View on GitHub
Comments
0
Participants
1
Timeline
4
Reactions
0
Author
Participants
Timeline (top)
labeled ×4

Root Cause

Cowork's value proposition is autonomous task execution. Dispatch is designed to orchestrate multiple task sessions in parallel. But the permission model treats each child session as if it were a brand new conversation with an untrusted agent, even though the parent session (which the user is actively working in) already has access.

The result is that every start_task call that touches files requires the user to manually click "Allow" in the UI. For a workflow that spawns 3-5 tasks, that's 3-5 interruptions. If the user steps away (which is the whole point of autonomous operation), the tasks block indefinitely waiting for permission.

Fix Action

Fix / Workaround

When Dispatch spawns child task sessions via start_task, each child session is completely isolated from the parent. If the parent Dispatch session has mounted a directory (via request_cowork_directory), child sessions cannot access it. Each child must call request_cowork_directory independently, which triggers a separate user permission prompt every time.

Child task sessions created by start_task should inherit the parent Dispatch session's mounted directories without requiring a separate user prompt. The user already granted access when they mounted the folder in the parent session. Child sessions should operate within that same trust boundary.

Cowork's value proposition is autonomous task execution. Dispatch is designed to orchestrate multiple task sessions in parallel. But the permission model treats each child session as if it were a brand new conversation with an untrusted agent, even though the parent session (which the user is actively working in) already has access.

Code Example

{
  "cowork": {
    "inheritMountsToChildSessions": true
  }
}
RAW_BUFFERClick to expand / collapse

Feature Request

When Dispatch spawns child task sessions via start_task, each child session is completely isolated from the parent. If the parent Dispatch session has mounted a directory (via request_cowork_directory), child sessions cannot access it. Each child must call request_cowork_directory independently, which triggers a separate user permission prompt every time.

This makes autonomous multi-task workflows impractical. Spawning 3 parallel tasks means 3 separate permission popups for the same folder the parent already has access to.

Requested Behaviour

Child task sessions created by start_task should inherit the parent Dispatch session's mounted directories without requiring a separate user prompt. The user already granted access when they mounted the folder in the parent session. Child sessions should operate within that same trust boundary.

Why This Matters

Cowork's value proposition is autonomous task execution. Dispatch is designed to orchestrate multiple task sessions in parallel. But the permission model treats each child session as if it were a brand new conversation with an untrusted agent, even though the parent session (which the user is actively working in) already has access.

The result is that every start_task call that touches files requires the user to manually click "Allow" in the UI. For a workflow that spawns 3-5 tasks, that's 3-5 interruptions. If the user steps away (which is the whole point of autonomous operation), the tasks block indefinitely waiting for permission.

Current Workarounds

  1. Do all work in the parent Dispatch session (eliminates parallelism)
  2. Use start_code_task instead (inherits CLAUDE_CODE_WORKSPACE_HOST_PATHS, different permission model)
  3. Batch multiple operations into single large tasks (reduces prompt count but increases complexity)

None of these are good solutions. They all work around the permission model rather than fixing it.

Related Issues

This problem has been reported multiple times and closed without resolution:

  • #37713 (Dispatch sessions fully isolated, closed as "invalid")
  • #22665 (subagents don't inherit permission allowlist, closed as duplicate of #18950)
  • #27661 (subagents should inherit parent hooks and permissions)
  • #34604 (default workspace folder, closed as duplicate of #27514)

The pattern across all of these is the same: child sessions need to inherit parent permissions.

Proposed Implementation

When start_task creates a child session, propagate the parent's mounted directory paths to the child session's filesystem scope. No additional user prompt needed because the user already authorised access in the parent session.

If full inheritance is a security concern, an alternative would be a user setting:

{
  "cowork": {
    "inheritMountsToChildSessions": true
  }
}

Environment

  • Windows 11 (ARM/Snapdragon)
  • Claude Desktop (latest, April 2026)
  • Cowork mode with Dispatch
  • Workspace: single folder (C:\Users\User\Projects) used across all sessions

extent analysis

TL;DR

Propagate the parent's mounted directory paths to the child session's filesystem scope when start_task creates a child session, to avoid additional user prompts.

Guidance

  • Review the proposed implementation to propagate mounted directory paths from parent to child sessions, ensuring it aligns with security requirements.
  • Consider adding a user setting, such as inheritMountsToChildSessions, to control this behavior and provide flexibility.
  • Investigate the feasibility of modifying the start_task function to inherit permissions without requiring a separate user prompt for each child session.
  • Evaluate the security implications of inheriting parent permissions in child sessions to ensure it does not introduce vulnerabilities.

Example

{
  "cowork": {
    "inheritMountsToChildSessions": true
  }
}

This example illustrates a potential user setting to control the inheritance of mounted directories in child sessions.

Notes

The solution should balance the need for autonomous task execution with security concerns, ensuring that the proposed implementation does not compromise the system's security.

Recommendation

Apply the proposed implementation to propagate mounted directory paths from parent to child sessions, as it addresses the core issue and provides a solution to the problem of repeated user prompts.

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…

Still need to ship something?

×6

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

Back to top recommendations

TRENDING

claude-code - 💡(How to fix) Fix [FEATURE] Cowork Dispatch: child task sessions should inherit parent's mounted directory [1 participants]