[FEATURE] visibility: "team" for routine-created sessions (config-level + /fire override)

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

Sessions created by a routine (Claude Code on the web) always land as Private to the routine owner's account, and there is no programmatic way to make them auto-share with Team visibility.

On a Team/Enterprise plan, the documented options are all manual or out-of-band:

• The /fire API body only accepts text — per the API reference, "Unknown fields in the body are ignored." So a visibility/shared field sent today is silently dropped.
• The routine config (docs) has no visibility/sharing field.
• Session visibility (Private ⇄ Team) is only a manual, post-hoc UI toggle at claude.ai/code, one session at a time.
• The per-routine bearer token "grants no read access… no access to account data," so a routine cannot self-share via any API as a final step either.

The result: any team running guardrailed review/build routines through the /fire API or a schedule cannot give teammates visibility into executions without a manual click per session.

Proposed Solution

Add a visibility: "private" | "team" option for routine-created sessions, settable at either level:

1. Routine config (job_config.ccr) — inherited by every run:

``jsonc
"job_config": { "ccr": { "visibility": "team", /* ...existing fields... */ } }
``

1. POST /v1/claude_code/routines/{id}/fire body — as a per-run override:

``bash
curl -X POST .../routines/$ROUTINE_ID/fire \
-H "Authorization: Bearer $TOKEN" \
-H "anthropic-beta: experimental-cc-routine-2026-04-01" \
-d '{"text": "...", "visibility": "team"}'
``

This reuses the existing Enterprise/Team Private⇄Team model — it just needs to be settable at config/run time instead of only in the UI after the fact.

Alternative Solutions

• Claude in Slack auto-shares sessions with Team visibility, but that entry point does not carry a routine's seed prompt, guardrails, pinned repo, or MCP connector config — so it isn't a substitute for a routine.
• Manual UI toggle per session (current workaround) — doesn't scale for automated/unattended runs.
• An org-level default visibility setting (all routine sessions default to Team) would also solve the problem if a per-routine field is too granular.

Priority

Medium - Would be very helpful

Feature Category

API and model interactions

Use Case Example

1. We define per-repo, guardrailed review/build routines (read-only/comment-only vs. push) and fire them from an internal dispatcher via the /fire API.
2. Each run creates a Private session under the firing account.
3. Today, a teammate cannot see the execution unless someone manually opens each session and toggles visibility to Team.
4. With visibility: "team" on the routine config (or /fire body), every execution would land as Shared with Team automatically — teammates get visibility into what the automation did with zero manual steps.

Additional Context

Related issues (none cover routine / API-triggered auto-share):

• #40981 — Share CC sessions with team (closed as duplicate; manual sharing only)
• #27702 — Live shareable session view (closed as not planned; opt-in live view)
• #18230 — Multi-developer shared sessions (real-time co-editing, not a visibility default)

Doc references:

• Routine /fire body schema: https://platform.claude.com/docs/en/api/claude-code/routines-fire
• Session visibility (Private/Team) model: https://code.claude.com/docs/en/claude-code-on-the-web#share-sessions
• Claude in Slack auto-Team-share behavior: https://code.claude.com/docs/en/slack