2026年5月3日 03:17

31 ファイル変更 +456 -645

この更新の概要

ディープリンク機能（claude-cli://）が導入され、ブラウザや他アプリから特定のディレクトリとプロンプトを指定してClaude Codeを起動できるようになりました。プランモードやGitワークツリーに関する説明が整理され、専用の解説ページへのリンク再編や用語の統一（Normal Modeからdefault modeへの変更など）が行われています。セッション管理コマンド（/rename、--continue、--resume）の使い分けや、ヘッドレスモードによるCI/CD統合の解説がより具体的に強化されました。フック機能やVS Code連携、スキル設定に関するドキュメントも拡充され、開発ワークフローに合わせたカスタマイズ性が向上しています。

agent-teams +1 -1

並列セッションの解説において、Gitワークツリーのリンク先が新しい専用ページに変更されました。

@@ -401,5 +401,5 @@ Agent teams are experimental. Current limitations to be aware of:

Explore related approaches for parallel work and delegation:

- **Lightweight delegation**: [subagents](/en/sub-agents) spawn helper agents for research or verification within your session, better for tasks that don't need inter-agent coordination

- **Manual parallel sessions**: [Git worktrees](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) let you run multiple Claude Code sessions yourself without automated team coordination

- **Manual parallel sessions**: [Git worktrees](/en/worktrees) let you run multiple Claude Code sessions yourself without automated team coordination

- **Compare approaches**: see the [subagent vs agent team](/en/features-overview#compare-similar-features) comparison for a side-by-side breakdown

best-practices +17 -23

プランモードやデフォルトモードの表記が小文字に統一され、セッション管理や並列実行の各手法について最新のドキュメント構成に基づいた解説に刷新されました。

@@ -3,7 +3,7 @@ title: best-practices

source: https://code.claude.com/docs/en/best-practices.md

---

# Best Practices for Claude Code

# Best practices for Claude Code

> Tips and patterns for getting the most out of Claude Code, from configuring your environment to scaling across parallel sessions.

@@ -49,40 +49,40 @@ Your verification can also be a test suite, a linter, or a Bash command that che

Separate research and planning from implementation to avoid solving the wrong problem.

Letting Claude jump straight to coding can produce code that solves the wrong problem. Use [Plan Mode](/en/common-workflows#use-plan-mode-for-safe-code-analysis) to separate exploration from execution.

Letting Claude jump straight to coding can produce code that solves the wrong problem. Use [plan mode](/en/permission-modes#analyze-before-you-edit-with-plan-mode) to separate exploration from execution.

The recommended workflow has four phases:

Enter Plan Mode. Claude reads files and answers questions without making changes.

Enter plan mode. Claude reads files and answers questions without making changes.

```txt claude (Plan Mode) theme={null}

```txt claude (plan mode) theme={null}

read /src/auth and understand how we handle sessions and login.

also look at how we manage environment variables for secrets.

```

Ask Claude to create a detailed implementation plan.

```txt claude (Plan Mode) theme={null}

```txt claude (plan mode) theme={null}

I want to add Google OAuth. What files need to change?

What's the session flow? Create a plan.

```

Press `Ctrl+G` to open the plan in your text editor for direct editing before Claude proceeds.

Switch back to Normal Mode and let Claude code, verifying against its plan.

Switch out of plan mode and let Claude code, verifying against its plan.

```txt claude (Normal Mode) theme={null}

```txt claude (default mode) theme={null}

implement the OAuth flow from your plan. write tests for the

callback handler, run the test suite and fix any failures.

```

Ask Claude to commit with a descriptive message and create a PR.

```txt claude (Normal Mode) theme={null}

```txt claude (default mode) theme={null}

commit with a descriptive message and open a PR

```

Plan Mode is useful, but also adds overhead.

Plan mode is useful, but also adds overhead.

For tasks where the scope is clear and the fix is small (like fixing a typo, adding a log line, or renaming a variable) ask Claude to do it directly.

@@ -388,16 +388,9 @@ Checkpoints only track changes made *by Claude*, not external processes. This is

### Resume conversations

Run `claude --continue` to pick up where you left off, or `--resume` to choose from recent sessions.

Name sessions with `/rename` and treat them like branches: each workstream gets its own persistent context.

Claude Code saves conversations locally. When a task spans multiple sessions, you don't have to re-explain the context:

```bash

claude --continue # Resume the most recent conversation

claude --resume # Select from recent conversations

```

Use `/rename` to give sessions descriptive names like `"oauth-migration"` or `"debugging-memory-leak"` so you can find them later. Treat sessions like branches: different workstreams can have separate, persistent contexts.

Claude Code saves conversations locally, so when a task spans multiple sittings you don't have to re-explain the context. Run `claude --continue` to pick up the most recent session, or `claude --resume` to choose from a list. Give sessions descriptive names like `oauth-migration` so you can find them later. See [Manage sessions](/en/sessions) for the full set of resume, branch, and naming controls.

***

@@ -411,7 +404,7 @@ Everything so far assumes one human, one Claude, and one conversation. But Claud

Use `claude -p "prompt"` in CI, pre-commit hooks, or scripts. Add `--output-format stream-json` for streaming JSON output.

With `claude -p "your prompt"`, you can run Claude non-interactively, without a session. Non-interactive mode is how you integrate Claude into CI pipelines, pre-commit hooks, or any automated workflow. The output formats let you parse results programmatically: plain text, JSON, or streaming JSON.

With `claude -p "your prompt"`, you can run Claude non-interactively, without a session. [Non-interactive mode](/en/headless) is how you integrate Claude into CI pipelines, pre-commit hooks, or any automated workflow. The output formats let you parse results programmatically: plain text, JSON, or streaming JSON.

```bash

# One-off queries

@@ -428,11 +421,12 @@ claude -p "Analyze this log file" --output-format stream-json

Run multiple Claude sessions in parallel to speed up development, run isolated experiments, or start complex workflows.

There are three main ways to run parallel sessions:

Pick the parallel approach that fits how much coordination you want to do yourself:

- [Claude Code desktop app](/en/desktop#work-in-parallel-with-sessions): Manage multiple local sessions visually. Each session gets its own isolated worktree.

- [Claude Code on the web](/en/claude-code-on-the-web): Run on Anthropic's secure cloud infrastructure in isolated VMs.

- [Agent teams](/en/agent-teams): Automated coordination of multiple sessions with shared tasks, messaging, and a team lead.

- [Worktrees](/en/worktrees): run separate CLI sessions in isolated git checkouts so edits don't collide

- [Desktop app](/en/desktop#work-in-parallel-with-sessions): manage multiple local sessions visually, each in its own worktree

- [Claude Code on the web](/en/claude-code-on-the-web): run sessions on Anthropic-managed cloud infrastructure in isolated VMs

- [Agent teams](/en/agent-teams): automated coordination of multiple sessions with shared tasks, messaging, and a team lead

Beyond parallelizing work, multiple sessions enable quality-focused workflows. A fresh context improves code review since Claude won't be biased toward code it just wrote.

checkpointing +1 -1

セッションの分岐（fork）に関する参照先が、新しいセッション管理専用ページへと更新されました。

@@ -44,7 +44,7 @@ The three restore options revert state: they undo code changes, conversation his

This is similar to `/compact`, but targeted: instead of summarizing the entire conversation, you keep early context in full detail and only compress the parts that are using up space. You can type optional instructions to guide what the summary focuses on.

Summarize keeps you in the same session and compresses context. If you want to branch off and try a different approach while preserving the original session intact, use [fork](/en/how-claude-code-works#resume-or-fork-sessions) instead (`claude --continue --fork-session`).

Summarize keeps you in the same session and compresses context. If you want to branch off and try a different approach while preserving the original session intact, use [fork](/en/sessions#branch-a-session) instead (`claude --continue --fork-session`).

## Common use cases

claude-directory +1 -1

.worktreeinclude設定の説明に含まれるリンク先が、新設されたワークツリー専用ページに変更されました。

@@ -66,7 +66,7 @@ Click a filename to open that node in the explorer above.

| [`commands/*.md`](#ce-commands) | Project and global | ✓ | Single-file prompts; same mechanism as skills | [Skills](/en/skills) |

| [`output-styles/*.md`](#ce-output-styles) | Project and global | ✓ | Custom system-prompt sections | [Output styles](/en/output-styles) |

cli-reference +1 -1

ワークツリーオプション（--worktree）の解説から、詳細なガイドページへのリンクが更新されました。

@@ -103,7 +103,7 @@ Customize Claude Code's behavior with these command-line flags. `claude --help`

| `--tools` | Restrict which built-in tools Claude can use. Use `""` to disable all, `"default"` for all, or tool names like `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |

| `--verbose` | Enable verbose logging, shows full turn-by-turn output | `claude --verbose` |

| `--version`, `-v` | Output the version number | `claude -v` |

| `--worktree`, `-w` | Start Claude in an isolated [git worktree](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) at `<repo>/.claude/worktrees/<name>`. If no name is given, one is auto-generated | `claude -w feature-auth` |

| `--worktree`, `-w` | Start Claude in an isolated [git worktree](/en/worktrees) at `<repo>/.claude/worktrees/<name>`. If no name is given, one is auto-generated | `claude -w feature-auth` |

### System prompt flags

code-review +1 -1

組織のクラウドインフラに関する記述において、AWS BedrockからAmazon Bedrockへと名称が修正されました。

@@ -229,7 +229,7 @@ The review trigger you choose affects total cost:

In any mode, commenting `@claude review` [opts the PR into push-triggered reviews](#manually-trigger-reviews), so additional cost accrues per push after that comment. To run a single review without subscribing to future pushes, comment `@claude review once` instead.

Costs appear on your Anthropic bill regardless of whether your organization uses AWS Bedrock or Google Vertex AI for other Claude Code features. To set a monthly spend cap for Code Review, go to [claude.ai/admin-settings/usage](https://claude.ai/admin-settings/usage) and configure the limit for the Claude Code Review service.

Costs appear on your Anthropic bill regardless of whether your organization uses Amazon Bedrock or Google Vertex AI for other Claude Code features. To set a monthly spend cap for Code Review, go to [claude.ai/admin-settings/usage](https://claude.ai/admin-settings/usage) and configure the limit for the Claude Code Review service.

Monitor spend via the weekly cost chart in [analytics](#view-usage) or the per-repo average cost column in admin settings.

commands +1 -1

/batchコマンドによる大規模変更の並列実行プロセスにおいて、参照されるリンク先がワークツリーの解説ページに変更されました。

@@ -24,7 +24,7 @@ In the table below, `<arg>` indicates a required argument and `[arg]` indicates

| `/add-dir <path>` | Add a working directory for file access during the current session. Most `.claude/` configuration is [not discovered](/en/permissions#additional-directories-grant-file-access-not-configuration) from the added directory. You can later resume the session from the added directory with `--continue` or `--resume` |

| `/agents` | Manage [agent](/en/sub-agents) configurations |

| `/autofix-pr [prompt]` | Spawn a [Claude Code on the web](/en/claude-code-on-the-web#auto-fix-pull-requests) session that watches the current branch's PR and pushes fixes when CI fails or reviewers leave comments. Detects the open PR from your checked-out branch with `gh pr view`; to watch a different PR, check out its branch first. By default the remote session is told to fix every CI failure and review comment; pass a prompt to give it different instructions, for example `/autofix-pr only fix lint and type errors`. Requires the `gh` CLI and access to [Claude Code on the web](/en/claude-code-on-the-web#who-can-use-claude-code-on-the-web) |

| `/batch <instruction>` | **[Skill](/en/skills#bundled-skills).** Orchestrate large-scale changes across a codebase in parallel. Researches the codebase, decomposes the work into 5 to 30 independent units, and presents a plan. Once approved, spawns one background agent per unit in an isolated [git worktree](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees). Each agent implements its unit, runs tests, and opens a pull request. Requires a git repository. Example: `/batch migrate src/ from Solid to React` |

| `/batch <instruction>` | **[Skill](/en/skills#bundled-skills).** Orchestrate large-scale changes across a codebase in parallel. Researches the codebase, decomposes the work into 5 to 30 independent units, and presents a plan. Once approved, spawns one background agent per unit in an isolated [git worktree](/en/worktrees). Each agent implements its unit, runs tests, and opens a pull request. Requires a git repository. Example: `/batch migrate src/ from Solid to React` |

| `/branch [name]` | Create a branch of the current conversation at this point. Switches you into the branch and preserves the original, which you can return to with `/resume`. Alias: `/fork`. When [`CLAUDE_CODE_FORK_SUBAGENT`](/en/env-vars) is set, `/fork` instead spawns a [forked subagent](/en/sub-agents#fork-the-current-conversation) and is no longer an alias for this command |

| `/btw <question>` | Ask a quick [side question](/en/interactive-mode#side-questions-with-%2Fbtw) without adding to the conversation |

| `/chrome` | Configure [Claude in Chrome](/en/chrome) settings |

common-workflows +81 -527

大幅なリファクタリングが行われ、ワークツリーやプランモードなどの詳細な解説がそれぞれの専用ページに移行されました。

(差分が大きいため省略しています)

costs +1 -1

コスト削減のためのプランモード活用において、リンク先がパーミッションモードの解説ページに更新されました。

@@ -173,7 +173,7 @@ Vague requests like "improve this codebase" trigger broad scanning. Specific req

For longer or more complex work, these habits help avoid wasted tokens from going down the wrong path:

- **Use plan mode for complex tasks**: Press Shift+Tab to enter [plan mode](/en/common-workflows#use-plan-mode-for-safe-code-analysis) before implementation. Claude explores the codebase and proposes an approach for your approval, preventing expensive re-work when the initial direction is wrong.

- **Use plan mode for complex tasks**: Press Shift+Tab to enter [plan mode](/en/permission-modes#analyze-before-you-edit-with-plan-mode) before implementation. Claude explores the codebase and proposes an approach for your approval, preventing expensive re-work when the initial direction is wrong.

- **Course-correct early**: If Claude starts heading the wrong direction, press Escape to stop immediately. Use `/rewind` or double-tap Escape to restore conversation and code to a previous checkpoint.

- **Give verification targets**: Include test cases, paste screenshots, or define expected output in your prompt. When Claude can verify its own work, it catches issues before you need to request fixes.

- **Test incrementally**: Write one file, test it, then continue. This catches issues early when they're cheap to fix.

deep-links +181 -0

カスタムURLスキーム（claude-cli://）を使用して、特定のディレクトリやプロンプトでセッションを開始するディープリンク機能の解説が新規追加されました。

@@ -0,0 +1,181 @@

---

title: deep-links

source: https://code.claude.com/docs/en/deep-links.md

---

# Launch sessions from links

> Open a Claude Code terminal session from a URL. Embed `claude-cli://` links in runbooks, alerts, and dashboards so a click opens Claude Code in the right repo with the right prompt.

A deep link is a `claude-cli://` URL that opens Claude Code in a new terminal window. The URL can carry a working directory and a prompt to pre-fill.

This lets you share a one-click starting point for a task: anyone with Claude Code installed who clicks the link sees a session open with the prompt already typed. The prompt is populated but not sent until you press Enter.

Because a deep link is a URL, you can put one anywhere a link can go:

- An incident runbook step that opens the affected service's repo with a diagnostic prompt

- A monitoring alert or dashboard that links to an investigation prompt for a specific metric

- A README or wiki page that opens the project with an onboarding prompt

- A CI failure notification that pre-fills the failing job's name

This page covers how to [build a link](#build-a-link), [embed one in a runbook or trigger it from the shell](#examples), and [manage or disable handler registration](#registration-and-supported-platforms) on each platform.

Deep links require Claude Code v2.1.91 or later.

## How it works

The `claude-cli://` prefix is a custom URL scheme that Claude Code registers with your operating system, similar to how `mailto:` links open your email client. The link can live on a web page, in a wiki, in a Slack message, or in any app that renders links. When you click one:

1. The browser or app hands the URL to your operating system.

2. The operating system recognizes the `claude-cli://` prefix and starts Claude Code on your machine.

3. A new terminal window opens with Claude Code running in the directory the link specified, and the link's prompt text already in the input box.

4. You read the prompt, edit it if you want, and press Enter to send it.

The link itself can be hosted anywhere, but the session always opens locally on the computer where you clicked. See [Registration and supported platforms](#registration-and-supported-platforms) for which terminal emulator opens on each operating system.

The platform that displays the link must allow custom URL schemes. GitHub-rendered Markdown allows `http` and `https` but strips schemes like `claude-cli://` in READMEs, issues, pull requests, and wikis. Only the link text shows, with no link behind it and the URL hidden. See [Troubleshooting](#the-link-renders-as-plain-text-instead-of-being-clickable) for a workaround.

### What a launched session shows

A deep link never executes anything on its own. The link only chooses a directory and fills the prompt box. If you click a link from a page you do not trust, the prompt is still inert: nothing reaches the model until you read what was filled in and press Enter.

When the session opens, a banner above the input shows that an external link launched it and which directory it selected. For prompts over 1,000 characters, the banner tells you to scroll and review the full text before pressing Enter, since long prompts can push instructions off screen. Permission rules, `CLAUDE.md`, and trust prompts for the selected directory apply the same way as for any other session.

## Build a link

Every deep link starts with `claude-cli://open`, which is the only path the handler accepts, followed by optional query parameters. The minimal form opens Claude Code in your home directory with an empty prompt:

```text

claude-cli://open

```

Add parameters to control where the session starts and what the prompt box contains:

| Parameter | Description |

| - | - |

| `q` | Text to pre-fill in the prompt box. [URL-encode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent) the value. Use `%0A` for line breaks in multi-line prompts. Maximum 5,000 characters. |

| `cwd` | Absolute path to use as the working directory. Network and UNC paths are rejected. |

| `repo` | A GitHub `owner/name` slug. Claude Code resolves it to a local clone it has seen before and starts there. If you have no matching clone, the session opens in your home directory instead. |

`cwd` and `repo` are [two ways to set the working directory](#choose-between-cwd-and-repo). If you pass both, `cwd` takes precedence and `repo` is ignored, even if the `cwd` path does not exist.

The following link points at a repository called `acme/payments` with a two-line diagnostic prompt. Replace `acme/payments` with your repository's `owner/name` slug when you build your own:

```text

claude-cli://open?repo=acme/payments&q=Investigate%20the%20failed%20deploy%20of%20payments-api.%0ACheck%20recent%20commits%20to%20main%20and%20the%20last%20successful%20build.

```

Clicking it opens a new terminal window, starts Claude Code in your local clone of `acme/payments`, and fills the prompt box with the decoded text:

```text

Investigate the failed deploy of payments-api.

Check recent commits to main and the last successful build.

```

You can edit the prompt before pressing Enter to send it. If you have no local clone of the repository, the session opens in your home directory instead. See [Choose between `cwd` and `repo`](#choose-between-cwd-and-repo) for how the local path is selected when you have multiple clones or worktrees.

### Choose between `cwd` and `repo`

Use `cwd` when everyone who clicks the link has the project at the same absolute path, such as a standardized devcontainer or VM image.

Use `repo` when the link is shared and each person clones to a different location. Claude Code resolves the slug to a local path as follows:

- Each time you run `claude` in a Git repository, that directory's filesystem path is recorded against the repository's GitHub `owner/name` slug.

- When a deep link arrives, `repo` opens whichever matching path you used most recently. Multiple clones and worktrees are tracked separately, so it picks the one you worked in last.

- The lookup only finds paths where you have already run Claude Code at least once.

- The link does not change which branch is checked out. The session opens in whatever state that directory is currently in.

The launched session shows which path it picked and when that clone last fetched from the remote, so you can tell if you are looking at stale code.

## Examples

The sections below show two common ways to use a deep link: as a Markdown link in a document and as a command in a script or shell alias.

### Embed a link in a runbook

A deep link in a runbook gives whoever is triaging a one-click way to start investigating in the right repository with a prepared prompt. The platform that renders the runbook must allow custom URL schemes. GitHub-rendered Markdown does not allow `claude-cli://`, so a deep link in a GitHub README, issue, or wiki shows only its label with no clickable link. See [the troubleshooting note](#the-link-renders-as-plain-text-instead-of-being-clickable) for a workaround.

The prompt is part of the URL and must be URL-encoded. To produce the encoded value, pass your prompt text through `encodeURIComponent` in a browser console or any URL encoder.

The example below adds an investigation entry point to an incident runbook for a service called `web-gateway`:

```markdown

## High 5xx rate on web-gateway

1. Acknowledge the page in PagerDuty.

2. [Open Claude Code in the gateway repo](claude-cli://open?repo=acme/web-gateway&q=5xx%20rate%20is%20elevated%20on%20web-gateway.%20Check%20recent%20deploys%2C%20error%20logs%20from%20the%20last%2030%20minutes%2C%20and%20open%20incidents%20in%20Linear.)

3. Post initial findings in #incident.

```

To use this in your own runbook, replace `acme/web-gateway` with your service's repository slug. This allows engineers with Claude Code installed and a local clone of that repository to click step 2 and start investigating with the prompt ready to send.

### Open a link from the shell

You can also open a deep link from a shell script, alias, or automation rather than by clicking it. Call your operating system's URL-opening command with the link as the argument.

The built-in `open` command passes the URL to the registered `claude-cli://` handler:

```bash theme={null}

open "claude-cli://open?repo=acme/payments&q=review%20open%20PRs"

```

Most desktop environments provide `xdg-open`, which passes the URL to the registered handler:

```bash theme={null}

xdg-open "claude-cli://open?repo=acme/payments&q=review%20open%20PRs"

```

In PowerShell, `Start-Process` passes the URL to the registered handler:

```powershell theme={null}

Start-Process "claude-cli://open?repo=acme/payments&q=review%20open%20PRs"

```

In `cmd.exe`, `start` treats its first quoted argument as a window title, so pass an empty title before the URL:

```cmd theme={null}

start "" "claude-cli://open?repo=acme/payments&q=review%20open%20PRs"

```

## Registration and supported platforms

Claude Code registers the `claude-cli://` handler with your operating system the first time you start an interactive session on macOS, Linux, and Windows. You do not run a separate install command. Registration writes to user-level locations only:

| Platform | Handler location |

| - | - |

| macOS | `~/Applications/Claude Code URL Handler.app` |

| Linux | `claude-code-url-handler.desktop` under `$XDG_DATA_HOME/applications`, defaulting to `~/.local/share/applications` |

| Windows | `HKEY_CURRENT_USER\Software\Classes\claude-cli` |

The handler launches Claude Code in a detected terminal emulator. On macOS, Claude Code remembers the terminal from your most recent interactive session and reuses it, supporting iTerm2, Ghostty, kitty, Alacritty, WezTerm, and Terminal.app. On Linux it honors the `$TERMINAL` environment variable, then `x-terminal-emulator`, then a list of common emulators. On Windows it prefers Windows Terminal, then PowerShell, then `cmd.exe`.

To prevent registration entirely, set [`disableDeepLinkRegistration`](/en/settings) to `"disable"` in `settings.json`. To enforce this across an organization so users cannot re-enable it, set it in [managed settings](/en/server-managed-settings) instead.

## Open a VS Code tab instead of a terminal

The VS Code extension registers its own handler at `vscode://anthropic.claude-code/open`, which opens a Claude Code editor tab rather than a terminal window. See [Launch a VS Code tab from other tools](/en/vs-code#launch-a-vs-code-tab-from-other-tools) for that URL's parameters.

## Troubleshooting

### Clicking the link does nothing

The handler likely is not registered yet. Start an interactive `claude` session once on that machine, exit, and try the link again. If you are on Linux without a desktop environment, `xdg-open` may have nothing to dispatch to.

### The link renders as plain text instead of being clickable

Some Markdown renderers only allow `http` and `https` links and strip other URL schemes. GitHub does this in READMEs, issues, pull requests, and wikis: `[label](claude-cli://...)` renders as just `label`, with no link and the URL removed. On these platforms, put the deep link in a code block so readers can see the URL and paste it into their browser's address bar.

### The session opens in my home directory instead of the repo

The `repo` parameter only resolves to clones Claude Code has already seen. Run `claude` inside the clone once so its path is recorded, or switch the link to use `cwd` with an absolute path.

### The link opens the wrong terminal

On macOS, start `claude` in your preferred terminal once and the next deep link will use it. On Linux, set the `$TERMINAL` environment variable to your preferred emulator's command name. On Windows, the order is fixed: install Windows Terminal if you want links to open there instead of a PowerShell or `cmd.exe` window.

## Learn more

These pages cover related ways to launch or extend Claude Code sessions:

- [Skills](/en/skills): store a long runbook prompt as a `/skill` in the repo so the deep link's `q` parameter only has to name it

- [Non-interactive mode](/en/headless): run Claude from a script and capture the output without opening a terminal

desktop +3 -3

デスクトップ版でのセッション管理とワークツリーの挙動に関する記述が調整されました。

@@ -257,11 +257,11 @@ Each session is an independent conversation with its own context and changes. Yo

### Work in parallel with sessions

Click **+ New session** in the sidebar, or press **Cmd+N** on macOS or **Ctrl+N** on Windows, to work on multiple tasks in parallel. Press **Ctrl+Tab** and **Ctrl+Shift+Tab** to cycle through sessions in the sidebar. For Git repositories, each session gets its own isolated copy of your project using [Git worktrees](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees), so changes in one session don't affect other sessions until you commit them.

Click **+ New session** in the sidebar, or press **Cmd+N** on macOS or **Ctrl+N** on Windows, to work on multiple tasks in parallel. Press **Ctrl+Tab** and **Ctrl+Shift+Tab** to cycle through sessions in the sidebar. For Git repositories, each session gets its own isolated copy of your project using [Git worktrees](/en/worktrees), so changes in one session don't affect other sessions until you commit them.

Worktrees are stored in `<project-root>/.claude/worktrees/` by default. You can change this to a custom directory in Settings → Claude Code under "Worktree location". You can also set a branch prefix that gets prepended to every worktree branch name, which is useful for keeping Claude-created branches organized. To remove a worktree when you're done, hover over the session in the sidebar and click the archive icon. To have sessions archive themselves when their pull request merges or closes, turn on **Auto-archive after PR merge or close** in Settings → Claude Code. Auto-archive only applies to local sessions that have finished running.

To include gitignored files like `.env` in new worktrees, create a [`.worktreeinclude` file](/en/common-workflows#copy-gitignored-files-to-worktrees) in your project root.

To include gitignored files like `.env` in new worktrees, create a [`.worktreeinclude` file](/en/worktrees#copy-gitignored-files-into-worktrees) in your project root.

Session isolation requires [Git](https://git-scm.com/downloads). Most Macs include Git by default. Run `git --version` in Terminal to check. On Windows, Git is required for the Code tab to work: [download Git for Windows](https://git-scm.com/downloads/win), install it, and restart the app. If you run into Git errors, ask Claude in the [Cowork tab](https://claude.com/product/cowork) to help troubleshoot your setup.

@@ -481,7 +481,7 @@ The desktop app does not always inherit your full shell environment. On macOS, w

To set environment variables for local sessions and dev servers on any platform, open the environment dropdown in the prompt box, hover over **Local**, and click the gear icon to open the local environment editor. Variables you save here are stored encrypted on your machine and apply to every local session and preview server you start. You can also add variables to the `env` key in your `~/.claude/settings.json` file, though these reach Claude sessions only and not dev servers. See [environment variables](/en/env-vars) for the full list of supported variables.

[Extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) is enabled by default, which improves performance on complex reasoning tasks but uses additional tokens. To disable thinking entirely, set `MAX_THINKING_TOKENS` to `0` in the local environment editor. On models with [adaptive reasoning](/en/model-config#adjust-effort-level), any other `MAX_THINKING_TOKENS` value is ignored because adaptive reasoning controls thinking depth instead. On Opus 4.6 and Sonnet 4.6, set `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` to `1` to use a fixed thinking budget; Opus 4.7 always uses adaptive reasoning and has no fixed-budget mode.

[Extended thinking](/en/model-config#extended-thinking) is enabled by default, which improves performance on complex reasoning tasks but uses additional tokens. To disable thinking entirely, set `MAX_THINKING_TOKENS` to `0` in the local environment editor. On models with [adaptive reasoning](/en/model-config#adjust-effort-level), any other `MAX_THINKING_TOKENS` value is ignored because adaptive reasoning controls thinking depth instead. On Opus 4.6 and Sonnet 4.6, set `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` to `1` to use a fixed thinking budget; Opus 4.7 always uses adaptive reasoning and has no fixed-budget mode.

### Remote sessions

errors +1 -1

エラー発生時のトラブルシューティングに関連する内部リンクの整合性が保たれるよう修正されました。

@@ -486,7 +486,7 @@ Claude Code adjusts these values automatically on the Anthropic API. You typical

**What to do:**

- Lower `MAX_THINKING_TOKENS`, or raise [`CLAUDE_CODE_MAX_OUTPUT_TOKENS`](/en/env-vars) above the thinking budget

- See [Extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) for how the budget interacts with output length

- See [Extended thinking](/en/model-config#extended-thinking) for how the budget interacts with output length

### Tool use or thinking block mismatch

github-actions +8 -8

GitHub Actionsを利用した非対話モードでの自動化ワークフローにおける説明が更新されました。

@@ -42,8 +42,8 @@ This command will guide you through setting up the GitHub app and required secre

- You must be a repository admin to install the GitHub app and add secrets

- The GitHub app will request read & write permissions for Contents, Issues, and Pull requests

- This quickstart method is only available for direct Claude API users. If

you're using AWS Bedrock or Google Vertex AI, please see the [Using with AWS

Bedrock & Google Vertex AI](#using-with-aws-bedrock-%26-google-vertex-ai)

you're using Amazon Bedrock or Google Vertex AI, see the [Using with Amazon

Bedrock & Google Vertex AI](#using-with-amazon-bedrock-%26-google-vertex-ai)

section.

## Manual setup

@@ -264,7 +264,7 @@ Visit the [examples directory](https://github.com/anthropics/claude-code-action/

When responding to issue or PR comments, Claude automatically responds to @claude mentions. For other events, use the `prompt` parameter to provide instructions.

## Using with AWS Bedrock & Google Vertex AI

## Using with Amazon Bedrock & Google Vertex AI

For enterprise environments, you can use Claude Code GitHub Actions with your own cloud infrastructure. This approach gives you control over data residency and billing while maintaining the same functionality.

@@ -279,7 +279,7 @@ Before setting up Claude Code GitHub Actions with cloud providers, you need:

3. A service account with the required permissions

4. A GitHub App (recommended) or use the default GITHUB\_TOKEN

#### For AWS Bedrock:

#### For Amazon Bedrock:

1. An AWS account with Amazon Bedrock enabled

2. GitHub OIDC Identity Provider configured in AWS

@@ -411,7 +411,7 @@ Add the following secrets to your repository (Settings → Secrets and variables

- `APP_ID`: Your GitHub App's ID

- `APP_PRIVATE_KEY`: The private key (.pem) content

#### For AWS Bedrock

#### For Amazon Bedrock

1. **For AWS Authentication**:

- `AWS_ROLE_TO_ASSUME`

@@ -420,11 +420,11 @@ Add the following secrets to your repository (Settings → Secrets and variables

- `APP_ID`: Your GitHub App's ID

- `APP_PRIVATE_KEY`: The private key (.pem) content

Create GitHub Actions workflow files that integrate with your cloud provider. The examples below show complete configurations for both AWS Bedrock and Google Vertex AI:

Create GitHub Actions workflow files that integrate with your cloud provider. The examples below show complete configurations for both Amazon Bedrock and Google Vertex AI:

**Prerequisites:**

- AWS Bedrock access enabled with Claude model permissions

- Amazon Bedrock access enabled with Claude model permissions

- GitHub configured as an OIDC identity provider in AWS

- IAM role with Bedrock permissions that trusts GitHub Actions

@@ -586,7 +586,7 @@ The Claude Code Action v1 uses a simplified configuration:

| `anthropic_api_key` | Claude API key | Yes\*\* |

| `github_token` | GitHub token for API access | No |

| `trigger_phrase` | Custom trigger phrase (default: "@claude") | No |

| `use_bedrock` | Use AWS Bedrock instead of Claude API | No |

| `use_bedrock` | Use Amazon Bedrock instead of Claude API | No |

| `use_vertex` | Use Google Vertex AI instead of Claude API | No |

\*Prompt is optional - when omitted for issue/PR comments, Claude responds to trigger phrase\

gitlab-ci-cd +9 -9

GitLab CI/CDにおける非対話モードの統合方法と環境設定に関する記述が微調整されました。

@@ -19,7 +19,7 @@ This integration is built on top of the [Claude Code CLI and Agent SDK](/en/agen

- **Automated implementation**: Turn issues into working code with a single command or mention

- **Project-aware**: Claude follows your `CLAUDE.md` guidelines and existing code patterns

- **Simple setup**: Add one job to `.gitlab-ci.yml` and a masked CI/CD variable

- **Enterprise-ready**: Choose Claude API, AWS Bedrock, or Google Vertex AI to meet data residency and procurement needs

- **Enterprise-ready**: Choose Claude API, Amazon Bedrock, or Google Vertex AI to meet data residency and procurement needs

- **Secure by default**: Runs in your GitLab runners with your branch protection and approvals

## How it works

@@ -30,7 +30,7 @@ Claude Code uses GitLab CI/CD to run AI tasks in isolated jobs and commit result

2. **Provider abstraction**: Use the provider that fits your environment:

- Claude API (SaaS)

- AWS Bedrock (IAM-based access, cross-region options)

- Amazon Bedrock (IAM-based access, cross-region options)

- Google Vertex AI (GCP-native, Workload Identity Federation)

3. **Sandboxed execution**: Each interaction runs in a container with strict network and filesystem rules. Claude Code enforces workspace-scoped permissions to constrain writes. Every change flows through an MR so reviewers see the diff and approvals still apply.

@@ -94,7 +94,7 @@ claude:

After adding the job and your `ANTHROPIC_API_KEY` variable, test by running the job manually from **CI/CD** → **Pipelines**, or trigger it from an MR to let Claude propose updates in a branch and open an MR if needed.

To run on AWS Bedrock or Google Vertex AI instead of the Claude API, see the [Using with AWS Bedrock & Google Vertex AI](#using-with-aws-bedrock--google-vertex-ai) section below for authentication and environment setup.

To run on Amazon Bedrock or Google Vertex AI instead of the Claude API, see the [Using with Amazon Bedrock & Google Vertex AI](#using-with-amazon-bedrock--google-vertex-ai) section below for authentication and environment setup.

### Manual setup (recommended for production)

@@ -102,7 +102,7 @@ If you prefer a more controlled setup or need enterprise providers:

1. **Configure provider access**:

- **Claude API**: Create and store `ANTHROPIC_API_KEY` as a masked CI/CD variable

- **AWS Bedrock**: **Configure GitLab** → **AWS OIDC** and create an IAM role for Bedrock

- **Amazon Bedrock**: **Configure GitLab** → **AWS OIDC** and create an IAM role for Bedrock

- **Google Vertex AI**: **Configure Workload Identity Federation for GitLab** → **GCP**

2. **Add project credentials for GitLab API operations**:

@@ -147,13 +147,13 @@ In an issue or MR comment:

Claude locates the bug, implements a fix, and updates the branch or opens a new MR.

## Using with AWS Bedrock & Google Vertex AI

## Using with Amazon Bedrock & Google Vertex AI

For enterprise environments, you can run Claude Code entirely on your cloud infrastructure with the same developer experience.

### Prerequisites

Before setting up Claude Code with AWS Bedrock, you need:

Before setting up Claude Code with Amazon Bedrock, you need:

1. An AWS account with Amazon Bedrock access to the desired Claude models

2. GitLab configured as an OIDC identity provider in AWS IAM

@@ -181,12 +181,12 @@ Configure AWS to allow GitLab CI jobs to assume an IAM role via OIDC (no static

Add variables in Settings → CI/CD → Variables:

```yaml theme={null}

# For AWS Bedrock:

# For Amazon Bedrock:

- AWS_ROLE_TO_ASSUME

- AWS_REGION

```

Use the AWS Bedrock job example above to exchange the GitLab job token for temporary AWS credentials at runtime.

Use the Amazon Bedrock job example above to exchange the GitLab job token for temporary AWS credentials at runtime.

### Prerequisites

@@ -260,7 +260,7 @@ claude:

# Claude Code will use ANTHROPIC_API_KEY from CI/CD variables

```

### AWS Bedrock job example (OIDC)

### Amazon Bedrock job example (OIDC)

**Prerequisites:**

glossary +2 -2

用語集内のリンクや定義が、最新のドキュメント構造に合わせてメンテナンスされました。

@@ -127,7 +127,7 @@ Learn more: [Adjust effort level](/en/model-config#adjust-effort-level)

Visible step-by-step reasoning the model performs before responding. You can cap thinking tokens with `MAX_THINKING_TOKENS` or adjust the [effort level](#effort-level). Thinking appears in gray italic text in the terminal.

Learn more: [Use extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode)

Learn more: [Use extended thinking](/en/model-config#extended-thinking)

## H

@@ -293,7 +293,7 @@ Learn more: [Tools available to Claude](/en/tools-reference)

An isolation mode that runs Claude in a separate git worktree under `.claude/worktrees/`, enabled with the `-w` flag or `isolation: worktree` in subagent config. Changes stay on a separate branch in a separate directory, so parallel agents don't overwrite each other's files.

Learn more: [Run parallel sessions with git worktrees](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees)

Learn more: [Run parallel sessions with git worktrees](/en/worktrees)

***

headless +26 -0

CIパイプラインなどで利用される非対話モード（ヘッドレスモード）に関する詳細な解説が大幅に拡充されました。

@@ -63,6 +63,32 @@ Bare mode skips OAuth and keychain reads. Anthropic authentication must come fro

These examples highlight common CLI patterns. For CI and other scripted calls, add [`--bare`](#start-faster-with-bare-mode) so they don't pick up whatever happens to be configured locally.

### Pipe data through Claude

Non-interactive mode reads stdin, so you can pipe data in and redirect the response out like any other command-line tool.

This example pipes a build log into Claude and writes the explanation to a file:

```bash

cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt

```

With `--output-format json`, the response payload includes `total_cost_usd` and a per-model cost breakdown, so scripted callers can track spend per invocation without consulting the [usage dashboard](/en/costs).

### Add Claude to a build script

You can wrap a non-interactive call in a script to use Claude as a project-specific linter or reviewer.

This `package.json` script pipes the diff against `main` into Claude and asks it to report typos. Piping the diff means Claude doesn't need Bash permission to read it, and the escaped double quotes keep the script portable to Windows:

```json

{

"scripts": {

"lint:claude": "git diff main | claude -p \"you are a typo linter. for each typo in this diff, report filename:line on one line and the issue on the next. return nothing else.\""

}

```

### Get structured output

Use `--output-format` to control how responses are returned:

hooks-guide +13 -0

カスタムフックを作成・利用するためのガイドラインが新しく追加され、環境構築のステップが詳述されました。

@@ -150,6 +150,19 @@ Nothing will appear yet. Open **System Settings > Notifications**, find **Script

}

```

The empty `matcher` fires on all notification types. To fire only on specific events, set it to one of these values:

| Matcher | Fires when |

| :- | :- |

| `permission_prompt` | Claude needs you to approve a tool use |

| `idle_prompt` | Claude is done and waiting for your next prompt |

| `auth_success` | Authentication completes |

| `elicitation_dialog` | An MCP server opens an elicitation form |

| `elicitation_complete` | An MCP elicitation form is submitted or dismissed |

| `elicitation_response` | An MCP elicitation response is sent back to the server |

Type `/hooks` and select `Notification` to confirm the hook is registered. For the full event schema, see the [Notification reference](/en/hooks#notification).

### Auto-format code after edits

Automatically run [Prettier](https://prettier.io/) on every file Claude edits, so formatting stays consistent without manual intervention.

hooks +1 -1

フック機能の全体像と各設定ファイルの役割に関する参照リンクが整備されました。

@@ -1966,7 +1966,7 @@ FileChanged hooks have no decision control. They cannot block the file change fr

When you run `claude --worktree` or a [subagent uses `isolation: "worktree"`](/en/sub-agents#choose-the-subagent-scope), Claude Code creates an isolated working copy using `git worktree`. If you configure a WorktreeCreate hook, it replaces the default git behavior, letting you use a different version control system like SVN, Perforce, or Mercurial.

Because the hook replaces the default behavior entirely, [`.worktreeinclude`](/en/common-workflows#copy-gitignored-files-to-worktrees) is not processed. If you need to copy local configuration files like `.env` into the new worktree, do it inside your hook script.

Because the hook replaces the default behavior entirely, [`.worktreeinclude`](/en/worktrees#copy-gitignored-files-into-worktrees) is not processed. If you need to copy local configuration files like `.env` into the new worktree, do it inside your hook script.

The hook must return the absolute path to the created worktree directory. Claude Code uses this path as the working directory for the isolated session. Command hooks print it on stdout; HTTP hooks return it via `hookSpecificOutput.worktreePath`.

how-claude-code-works +4 -12

セッションの再開やフォークの仕組みに関する解説が整理され、新しいドキュメント構成に適応されました。

@@ -99,25 +99,17 @@ Claude Code saves your conversation locally as you work. Each message, tool use,

### Work across branches

Each Claude Code conversation is a session tied to your current directory. The `/resume` picker shows sessions from the current worktree by default, with keyboard shortcuts to widen the list to other worktrees or projects. See [Resume previous conversations](/en/common-workflows#resume-previous-conversations) for the full list of picker shortcuts and how name resolution works.

Each Claude Code conversation is a session tied to your current directory. The `/resume` picker shows sessions from the current worktree by default, with keyboard shortcuts to widen the list to other worktrees or projects. See [Manage sessions](/en/sessions#use-the-session-picker) for the full list of picker shortcuts and how name resolution works.

Claude sees your current branch's files. When you switch branches, Claude sees the new branch's files, but your conversation history stays the same. Claude remembers what you discussed even after switching.

Since sessions are tied to directories, you can run parallel Claude sessions by using [git worktrees](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees), which create separate directories for individual branches.

Since sessions are tied to directories, you can run parallel Claude sessions by using [git worktrees](/en/worktrees), which create separate directories for individual branches.

### Resume or fork sessions

When you resume a session with `claude --continue` or `claude --resume`, you pick up where you left off using the same session ID. New messages append to the existing conversation. Your full conversation history is restored, but session-scoped permissions are not. You'll need to re-approve those.

Resuming a session with `claude --continue` or `claude --resume` reopens it under the same session ID and appends new messages to the existing conversation. Forking with `--fork-session` or `/branch` copies the history into a new session ID, leaving the original unchanged.

To branch off and try a different approach without affecting the original session, use the `--fork-session` flag:

```bash

claude --continue --fork-session

```

This creates a new session ID while preserving the conversation history up to that point. The original session remains unchanged. Like resume, forked sessions don't inherit session-scoped permissions.

**Same session in multiple terminals**: If you resume the same session in multiple terminals, both terminals write to the same session file. Messages from both get interleaved, like two people writing in the same notebook. Nothing corrupts, but the conversation becomes jumbled. Each terminal only sees its own messages during the session, but if you resume that session later, you'll see everything interleaved. For parallel work from the same starting point, use `--fork-session` to give each terminal its own clean session.

For the resume flags, the `/resume` picker, naming, and what happens when the same session is open in two terminals, see [Manage sessions](/en/sessions).

### The context window

legal-and-compliance +1 -1

法務およびコンプライアンスに関するセクションの内部参照リンクが修正されました。

@@ -18,7 +18,7 @@ Your use of Claude Code is subject to:

### Commercial agreements

Whether you're using the Claude API directly (1P) or accessing it through AWS Bedrock or Google Vertex (3P), your existing commercial agreement will apply to Claude Code usage, unless we've mutually agreed otherwise.

Whether you're using the Claude API directly (1P) or accessing it through Amazon Bedrock or Google Vertex (3P), your existing commercial agreement will apply to Claude Code usage, unless we've mutually agreed otherwise.

## Compliance

model-config +17 -3

使用するモデルの構成やパラメータ設定に関する詳細な説明と設定例が追加されました。

@@ -186,7 +186,9 @@ Each level trades token spend against capability. The default suits most coding

The effort scale is calibrated per model, so the same level name does not represent the same underlying value across models.

For one-off deep reasoning without changing your session setting, include "ultrathink" in your prompt. This adds an in-context instruction telling the model to reason more on that turn; it does not change the effort level sent to the API.

#### Use ultrathink for one-off deep reasoning

Include `ultrathink` anywhere in your prompt to request deeper reasoning on that turn without changing your session effort setting. Claude Code recognizes the keyword and adds an in-context instruction. The effort level sent to the API is unchanged. Other phrases such as "think", "think hard", and "think more" are passed through as ordinary prompt text and are not recognized as keywords.

#### Set the effort level

@@ -211,6 +213,18 @@ Opus 4.7 always uses adaptive reasoning. The fixed thinking budget mode and `CLA

On Opus 4.6 and Sonnet 4.6, you can set `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` to revert to the previous fixed thinking budget controlled by `MAX_THINKING_TOKENS`. See [environment variables](/en/env-vars).

### Extended thinking

Extended thinking is the reasoning Claude emits before responding. On models that support [adaptive reasoning](#adjust-effort-level), the effort level is the primary control for how much thinking happens; the settings below turn thinking on or off and control how it displays.

| Control | How to set it |

| :- | :- |

| Toggle for the current session | Press `Option+T` on macOS or `Alt+T` on Windows and Linux. May require [terminal configuration](/en/terminal-config) for Option-key shortcuts |

| Set the global default | Run `/config` and toggle thinking mode. Saved as `alwaysThinkingEnabled` in `~/.claude/settings.json` |

| Disable regardless of effort | Set [`MAX_THINKING_TOKENS=0`](/en/env-vars). Other values apply only with a [fixed thinking budget](#adaptive-reasoning-and-fixed-thinking-budgets) |

Thinking output is collapsed by default. Press `Ctrl+O` to toggle verbose mode and see the reasoning as gray italic text. Interactive sessions on the Anthropic API receive redacted thinking blocks by default, so set `showThinkingSummaries: true` in [settings](/en/settings) if you want the full summaries available when you expand. You are charged for all thinking tokens generated, even when collapsed or redacted.

### Extended context

Opus 4.7, Opus 4.6, and Sonnet 4.6 support a [1 million token context window](https://platform.claude.com/docs/en/build-with-claude/context-windows#1m-token-context-window) for long sessions with large codebases.

@@ -320,14 +334,14 @@ These variables take effect on third-party providers such as Bedrock, Vertex AI,

The same `_NAME`, `_DESCRIPTION`, and `_SUPPORTED_CAPABILITIES` suffixes are available for `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL`, and `ANTHROPIC_CUSTOM_MODEL_OPTION`.

Claude Code enables features like [effort levels](#adjust-effort-level) and [extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) by matching the model ID against known patterns. Provider-specific IDs such as Bedrock ARNs or custom deployment names often don't match these patterns, leaving supported features disabled. Set `_SUPPORTED_CAPABILITIES` to tell Claude Code which features the model actually supports:

Claude Code enables features like [effort levels](#adjust-effort-level) and [extended thinking](#extended-thinking) by matching the model ID against known patterns. Provider-specific IDs such as Bedrock ARNs or custom deployment names often don't match these patterns, leaving supported features disabled. Set `_SUPPORTED_CAPABILITIES` to tell Claude Code which features the model actually supports:

| Capability value | Enables |

| - | - |

| `effort` | [Effort levels](#adjust-effort-level) and the `/effort` command |

| `xhigh_effort` | The `xhigh` effort level |

| `max_effort` | The `max` effort level |

| `thinking` | [Extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) |

| `thinking` | [Extended thinking](#extended-thinking) |

| `adaptive_thinking` | Adaptive reasoning that dynamically allocates thinking based on task complexity |

| `interleaved_thinking` | Thinking between tool calls |

monitoring-usage +1 -1

利用状況のモニタリング方法に関するリンク先が、最新の管理画面パスに合わせて更新されました。

@@ -849,7 +849,7 @@ The `claude_code.cost.usage` metric helps with:

- Tracking usage trends across teams or individuals

- Identifying high-usage sessions for optimization

Cost metrics are approximations. For official billing data, refer to your API provider (Claude Console, AWS Bedrock, or Google Cloud Vertex).

Cost metrics are approximations. For official billing data, refer to your API provider (Claude Console, Amazon Bedrock, or Google Cloud Vertex).

### Alerting and segmentation

overview +1 -1

ツール全体の概要説明における内部リンクの整合性が修正されました。

@@ -523,7 +523,7 @@ Here are some of the ways you can use Claude Code:

[`CLAUDE.md`](/en/memory) is a markdown file you add to your project root that Claude Code reads at the start of every session. Use it to set coding standards, architecture decisions, preferred libraries, and review checklists. Claude also builds [auto memory](/en/memory#auto-memory) as it works, saving learnings like build commands and debugging insights across sessions without you writing anything.

Create [custom commands](/en/skills) to package repeatable workflows your team can share, like `/review-pr` or `/deploy-staging`.

Create [skills](/en/skills) to package repeatable workflows your team can share, like `/review-pr` or `/deploy-staging`.

[Hooks](/en/hooks) let you run shell commands before or after Claude Code actions, like auto-formatting after every file edit or running lint before a commit.

</Accordion>

permission-modes +17 -1

プランモードなどの権限設定に関する解説が独立したページとして整理され、より詳細な制御方法が記載されました。

@@ -117,6 +117,8 @@ claude --permission-mode plan

Press `Shift+Tab` again to leave plan mode without approving a plan.

### Review and approve a plan

When the plan is ready, Claude presents it and asks how to proceed. From that prompt you can:

- Approve and start in auto mode

@@ -125,7 +127,21 @@ When the plan is ready, Claude presents it and asks how to proceed. From that pr

- Keep planning with feedback

- Refine with [Ultraplan](/en/ultraplan) for browser-based review

Each approve option also offers to clear the planning context first.

Press `Ctrl+G` to open the proposed plan in your default text editor and edit it directly before Claude proceeds. When [`showClearContextOnPlanAccept`](/en/settings#available-settings) is enabled, each approve option also offers to clear the planning context first.

Accepting a plan also names the session from the plan content automatically, unless you've already set a name with `--name` or `/rename`.

### Set plan mode as the default

To make plan mode the default for a project, set `defaultMode` in `.claude/settings.json`:

```json

{

"permissions": {

"defaultMode": "plan"

}

```

## Eliminate prompts with auto mode

remote-control +1 -1

リモート環境からの操作に関するリンクが最新の状態に更新されました。

@@ -49,7 +49,7 @@ Available flags:

| - | - |

| `--name "My Project"` | Set a custom session title visible in the session list at claude.ai/code. |

| `--remote-control-session-name-prefix <prefix>` | Prefix for auto-generated session names when no explicit name is set. Defaults to your machine's hostname, producing names like `myhost-graceful-unicorn`. Set `CLAUDE_REMOTE_CONTROL_SESSION_NAME_PREFIX` for the same effect. |

| `--spawn <mode>` | How the server creates sessions.• `same-dir` (default): all sessions share the current working directory, so they can conflict if editing the same files.• `worktree`: each on-demand session gets its own [git worktree](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees). Requires a git repository.• `session`: single-session mode. Serves exactly one session and rejects additional connections. Set at startup only.Press `w` at runtime to toggle between `same-dir` and `worktree`. |

| `--spawn <mode>` | How the server creates sessions.• `same-dir` (default): all sessions share the current working directory, so they can conflict if editing the same files.• `worktree`: each on-demand session gets its own [git worktree](/en/worktrees). Requires a git repository.• `session`: single-session mode. Serves exactly one session and rejects additional connections. Set at startup only.Press `w` at runtime to toggle between `same-dir` and `worktree`. |

| `--capacity <N>` | Maximum number of concurrent sessions. Default is 32. Cannot be used with `--spawn=session`. |

| `--verbose` | Show detailed connection and session logs. |

| `--sandbox` / `--no-sandbox` | Enable or disable [sandboxing](/en/sandboxing) for filesystem and network isolation. Off by default. |

settings +5 -5

設定変更に関するコマンドや構成ファイルの記述が最新の仕様に合わせて微修正されました。

@@ -160,7 +160,7 @@ The published schema is updated periodically and may not include settings added

| `allowManagedHooksOnly` | (Managed settings only) Only managed hooks, SDK hooks, and hooks from plugins force-enabled in managed settings `enabledPlugins` are loaded. User, project, and all other plugin hooks are blocked. See [Hook configuration](#hook-configuration) | `true` |

| `allowManagedMcpServersOnly` | (Managed settings only) Only `allowedMcpServers` from managed settings are respected. `deniedMcpServers` still merges from all sources. Users can still add MCP servers, but only the admin-defined allowlist applies. See [Managed MCP configuration](/en/mcp#managed-mcp-configuration) | `true` |

| `allowManagedPermissionRulesOnly` | (Managed settings only) Prevent user and project settings from defining `allow`, `ask`, or `deny` permission rules. Only rules in managed settings apply. See [Managed-only settings](/en/permissions#managed-only-settings) | `true` |

| `alwaysThinkingEnabled` | Enable [extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) by default for all sessions. Typically configured via the `/config` command rather than editing directly | `true` |

| `alwaysThinkingEnabled` | Enable [extended thinking](/en/model-config#extended-thinking) by default for all sessions. Typically configured via the `/config` command rather than editing directly | `true` |

| `apiKeyHelper` | Custom script, to be executed in `/bin/sh`, to generate an auth value. This value will be sent as `X-Api-Key` and `Authorization: Bearer` headers for model requests | `/bin/generate_temp_api_key.sh` |

| `attribution` | Customize attribution for git commits and pull requests. See [Attribution settings](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |

| `autoMemoryDirectory` | Custom directory for [auto memory](/en/memory#storage-location) storage. Accepts `~/`-expanded paths. Not accepted in project settings (`.claude/settings.json`) to prevent shared repos from redirecting memory writes to sensitive locations. Accepted from policy, local, and user settings | `"~/my-memory-dir"` |

@@ -173,13 +173,13 @@ The published schema is updated periodically and may not include settings added

| `awsCredentialExport` | Custom script that outputs JSON with AWS credentials (see [advanced credential configuration](/en/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |

| `blockedMarketplaces` | (Managed settings only) Blocklist of marketplace sources. Enforced on marketplace add and on plugin install, update, refresh, and auto-update, so a marketplace added before the policy was set cannot be used to fetch plugins. Blocked sources are checked before downloading, so they never touch the filesystem. See [Managed marketplace restrictions](/en/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |

| `channelsEnabled` | (Managed settings only) Allow [channels](/en/channels) for Team and Enterprise users. Unset or `false` blocks channel message delivery regardless of what users pass to `--channels` | `true` |

| `cleanupPeriodDays` | Session files older than this period are deleted at startup (default: 30 days, minimum 1). Setting to `0` is rejected with a validation error. Also controls the age cutoff for automatic removal of [orphaned subagent worktrees](/en/common-workflows#worktree-cleanup) at startup. To disable transcript writes entirely, set the [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/en/env-vars) environment variable, or in non-interactive mode (`-p`) use the `--no-session-persistence` flag or the `persistSession: false` SDK option. | `20` |

| `cleanupPeriodDays` | Session files older than this period are deleted at startup (default: 30 days, minimum 1). Setting to `0` is rejected with a validation error. Also controls the age cutoff for automatic removal of [orphaned subagent worktrees](/en/worktrees#clean-up-worktrees) at startup. To disable transcript writes entirely, set the [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/en/env-vars) environment variable, or in non-interactive mode (`-p`) use the `--no-session-persistence` flag or the `persistSession: false` SDK option. | `20` |

| `companyAnnouncements` | Announcement to display to users at startup. If multiple announcements are provided, they will be cycled through at random. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |

| `defaultShell` | Default shell for input-box `!` commands. Accepts `"bash"` (default) or `"powershell"`. Setting `"powershell"` routes interactive `!` commands through PowerShell on Windows. Requires `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. See [PowerShell tool](/en/tools-reference#powershell-tool) | `"powershell"` |

| `deniedMcpServers` | When set in managed-settings.json, denylist of MCP servers that are explicitly blocked. Applies to all scopes including managed servers. Denylist takes precedence over allowlist. See [Managed MCP configuration](/en/mcp#managed-mcp-configuration) | `[{ "serverName": "filesystem" }]` |

| `disableAllHooks` | Disable all [hooks](/en/hooks) and any custom [status line](/en/statusline) | `true` |

| `disableAutoMode` | Set to `"disable"` to prevent [auto mode](/en/permission-modes#eliminate-prompts-with-auto-mode) from being activated. Removes `auto` from the `Shift+Tab` cycle and rejects `--permission-mode auto` at startup. Most useful in [managed settings](/en/permissions#managed-settings) where users cannot override it | `"disable"` |

| `disableDeepLinkRegistration` | Set to `"disable"` to prevent Claude Code from registering the `claude-cli://` protocol handler with the operating system on startup. Deep links let external tools open a Claude Code session with a pre-filled prompt via `claude-cli://open?q=...`. The `q` parameter supports multi-line prompts using URL-encoded newlines (`%0A`). Useful in environments where protocol handler registration is restricted or managed separately | `"disable"` |

| `disableDeepLinkRegistration` | Set to `"disable"` to prevent Claude Code from registering the `claude-cli://` protocol handler with the operating system on startup. [Deep links](/en/deep-links) let external tools open a Claude Code session with a pre-filled prompt. Useful in environments where protocol handler registration is restricted or managed separately | `"disable"` |

| `disabledMcpjsonServers` | List of specific MCP servers from `.mcp.json` files to reject | `["filesystem"]` |

| `disableSkillShellExecution` | Disable inline shell execution for `` !`...` `` and ` ```! ` blocks in [skills](/en/skills) and custom commands from user, project, plugin, or additional-directory sources. Commands are replaced with `[shell command execution disabled by policy]` instead of being run. Bundled and managed skills are not affected. Most useful in [managed settings](/en/permissions#managed-settings) where users cannot override it | `true` |

| `editorMode` | Key binding mode for the input prompt: `"normal"` or `"vim"`. Default: `"normal"`. Appears in `/config` as **Editor mode** | `"vim"` |

@@ -211,7 +211,7 @@ The published schema is updated periodically and may not include settings added

| `prUrlTemplate` | URL template for the PR badge shown in the footer and in tool-result summaries. Substitutes `{host}`, `{owner}`, `{repo}`, `{number}`, and `{url}` from the `gh`-reported PR URL. Use to point PR links at an internal code-review tool instead of `github.com`. Does not affect `#123` autolinks in Claude's prose | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |

| `respectGitignore` | Control whether the `@` file picker respects `.gitignore` patterns. When `true` (default), files matching `.gitignore` patterns are excluded from suggestions | `false` |

| `showClearContextOnPlanAccept` | Show the "clear context" option on the plan accept screen. Defaults to `false`. Set to `true` to restore the option | `true` |

| `showThinkingSummaries` | Show [extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) summaries in interactive sessions. When unset or `false` (default in interactive mode), thinking blocks are redacted by the API and shown as a collapsed stub. Redaction only changes what you see, not what the model generates: to reduce thinking spend, [lower the budget or disable thinking](/en/common-workflows#use-extended-thinking-thinking-mode) instead. Non-interactive mode (`-p`) and SDK callers always receive summaries regardless of this setting | `true` |

| `showThinkingSummaries` | Show [extended thinking](/en/model-config#extended-thinking) summaries in interactive sessions. When unset or `false` (default in interactive mode), thinking blocks are redacted by the API and shown as a collapsed stub. Redaction only changes what you see, not what the model generates: to reduce thinking spend, [lower the budget or disable thinking](/en/model-config#extended-thinking) instead. Non-interactive mode (`-p`) and SDK callers always receive summaries regardless of this setting | `true` |

| `showTurnDuration` | Show turn duration messages after responses, e.g. "Cooked for 1m 6s". Default: `true`. Appears in `/config` as **Show turn duration** | `false` |

| `skipWebFetchPreflight` | Skip the [WebFetch domain safety check](/en/data-usage#webfetch-domain-safety-check) that sends each requested hostname to `api.anthropic.com` before fetching. Set to `true` in environments that block traffic to Anthropic, such as Bedrock, Vertex AI, or Foundry deployments with restrictive egress. When skipped, WebFetch attempts any URL without consulting the blocklist | `true` |

| `spinnerTipsEnabled` | Show tips in the spinner while Claude is working. Set to `false` to disable tips (default: `true`) | `false` |

@@ -250,7 +250,7 @@ Configure how `--worktree` creates and manages git worktrees. Use these settings

| `worktree.symlinkDirectories` | Directories to symlink from the main repository into each worktree to avoid duplicating large directories on disk. No directories are symlinked by default | `["node_modules", ".cache"]` |

| `worktree.sparsePaths` | Directories to check out in each worktree via git sparse-checkout (cone mode). Only the listed paths are written to disk, which is faster in large monorepos | `["packages/my-app", "shared/utils"]` |

To copy gitignored files like `.env` into new worktrees, use a [`.worktreeinclude` file](/en/common-workflows#copy-gitignored-files-to-worktrees) in your project root instead of a setting.

To copy gitignored files like `.env` into new worktrees, use a [`.worktreeinclude` file](/en/worktrees#copy-gitignored-files-into-worktrees) in your project root instead of a setting.

### Permission settings

skills +34 -29

バンドルされているスキルの詳細や、/batchなどの高度なコマンドの使い方が詳しく解説されました。

@@ -9,7 +9,7 @@ source: https://code.claude.com/docs/en/skills.md

Skills extend what Claude can do. Create a `SKILL.md` file with instructions, and Claude adds it to its toolkit. Claude uses skills when relevant, or you can invoke one directly with `/skill-name`.

Create a skill when you keep pasting the same playbook, checklist, or multi-step procedure into chat, or when a section of CLAUDE.md has grown into a procedure rather than a fact. Unlike CLAUDE.md content, a skill's body loads only when it's used, so long reference material costs almost nothing until you need it.

Create a skill when you keep pasting the same instructions, checklist, or multi-step procedure into chat, or when a section of CLAUDE.md has grown into a procedure rather than a fact. Unlike CLAUDE.md content, a skill's body loads only when it's used, so long reference material costs almost nothing until you need it.

For built-in commands like `/help` and `/compact`, and bundled skills like `/debug` and `/simplify`, see the [commands reference](/en/commands).

@@ -19,7 +19,7 @@ Claude Code skills follow the [Agent Skills](https://agentskills.io) open standa

## Bundled skills

Claude Code includes a set of bundled skills that are available in every session, including `/simplify`, `/batch`, `/debug`, `/loop`, and `/claude-api`. Unlike most built-in commands, which execute fixed logic directly, bundled skills are prompt-based: they give Claude a detailed playbook and let it orchestrate the work using its tools. You invoke them the same way as any other skill, by typing `/` followed by the skill name.

Claude Code includes a set of bundled skills that are available in every session, including `/simplify`, `/batch`, `/debug`, `/loop`, and `/claude-api`. Unlike most built-in commands, which execute fixed logic directly, bundled skills are prompt-based: they give Claude detailed instructions and let it orchestrate the work using its tools. You invoke them the same way as any other skill, by typing `/` followed by the skill name.

Bundled skills are listed alongside built-in commands in the [commands reference](/en/commands), marked **Skill** in the Purpose column.

@@ -27,48 +27,49 @@ Bundled skills are listed alongside built-in commands in the [commands reference

### Create your first skill

This example creates a skill that teaches Claude to explain code using visual diagrams and analogies. Since it uses default frontmatter, Claude can load it automatically when you ask how something works, or you can invoke it directly with `/explain-code`.

This example creates a skill that summarizes the uncommitted changes in your git repository and flags anything risky. It pulls the live diff into the prompt before Claude reads it, so the response is grounded in your actual working tree rather than what Claude can guess from open files. Claude loads the skill automatically when you ask about your changes, or you can invoke it directly with `/summarize-changes`.

Create a directory for the skill in your personal skills folder. Personal skills are available across all your projects.

```bash theme={null}

mkdir -p ~/.claude/skills/explain-code

mkdir -p ~/.claude/skills/summarize-changes

```

Every skill needs a `SKILL.md` file with two parts: YAML frontmatter (between `---` markers) that tells Claude when to use the skill, and markdown content with instructions Claude follows when the skill is invoked. The directory name becomes the `/slash-command`, and the `description` helps Claude decide when to load it automatically.

Every skill needs a `SKILL.md` file with two parts: YAML frontmatter between `---` markers that tells Claude when to use the skill, and markdown content with the instructions Claude follows when the skill runs. The directory name becomes the command you type, and the `description` helps Claude decide when to load the skill automatically.

Create `~/.claude/skills/explain-code/SKILL.md`:

Save this to `~/.claude/skills/summarize-changes/SKILL.md`:

```yaml theme={null}

---

description: Explains code with visual diagrams and analogies. Use when explaining how code works, teaching about a codebase, or when the user asks "how does this work?"

description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.

---

When explaining code, always include:

## Current changes

1. **Start with an analogy**: Compare the code to something from everyday life

2. **Draw a diagram**: Use ASCII art to show the flow, structure, or relationships

3. **Walk through the code**: Explain step-by-step what happens

4. **Highlight a gotcha**: What's a common mistake or misconception?

!`git diff HEAD`

Keep explanations conversational. For complex concepts, use multiple analogies.

## Instructions

Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

```

You can test it two ways:

The `` !`git diff HEAD` `` line uses [dynamic context injection](#inject-dynamic-context): Claude Code runs the command and replaces the line with its output before Claude sees the skill content, so the instructions arrive with the current diff already inlined.

Open a git project, make a small edit to any file, and start Claude Code by running `claude`. You can test the skill two ways.

**Let Claude invoke it automatically** by asking something that matches the description:

```text theme={null}

How does this code work?

What did I change?

```

**Or invoke it directly** with the skill name:

```text theme={null}

/explain-code src/auth/login.ts

/summarize-changes

```

Either way, Claude should include an analogy and ASCII diagram in its explanation.

Either way, Claude should respond with a short summary of your edit and a list of risks.

### Where skills live

@@ -175,7 +176,7 @@ All fields are optional. Only `description` is recommended so Claude knows when

| Field | Required | Description |

| :- | :- | :- |

| `name` | No | Display name for the skill. If omitted, uses the directory name. Lowercase letters, numbers, and hyphens only (max 64 characters). |

| `description` | Recommended | What the skill does and when to use it. Claude uses this to decide when to apply the skill. If omitted, uses the first paragraph of markdown content. Front-load the key use case: the combined `description` and `when_to_use` text is truncated at 1,536 characters in the skill listing to reduce context usage. |

| `description` | Recommended | What the skill does and when to use it. Claude uses this to decide when to apply the skill. If omitted, uses the first paragraph of markdown content. Put the key use case first: the combined `description` and `when_to_use` text is truncated at 1,536 characters in the skill listing to reduce context usage. |

| `when_to_use` | No | Additional context for when Claude should invoke the skill, such as trigger phrases or example requests. Appended to `description` in the skill listing and counts toward the 1,536-character cap. |

| `argument-hint` | No | Hint shown during autocomplete to indicate expected arguments. Example: `[issue-number]` or `[filename] [format]`. |

| `arguments` | No | Named positional arguments for [`$name` substitution](#available-string-substitutions) in the skill content. Accepts a space-separated string or a YAML list. Names map to argument positions in order. |

@@ -290,6 +291,8 @@ If a skill seems to stop influencing behavior after the first response, the cont

The `allowed-tools` field grants permission for the listed tools while the skill is active, so Claude can use them without prompting you for approval. It does not restrict which tools are available: every tool remains callable, and your [permission settings](/en/permissions) still govern tools that are not listed.

For skills checked into a project's `.claude/skills/` directory, `allowed-tools` takes effect after you accept the workspace trust dialog for that folder, the same as permission rules in `.claude/settings.json`. Review project skills before trusting a repository, since a skill can grant itself broad tool access.

This skill lets Claude run git commands without per-use approval whenever you invoke it:

```yaml

@@ -400,7 +403,7 @@ git status --short

To disable this behavior for skills and custom commands from user, project, plugin, or [additional-directory](#skills-from-additional-directories) sources, set `"disableSkillShellExecution": true` in [settings](/en/settings). Each command is replaced with `[shell command execution disabled by policy]` instead of being run. Bundled and managed skills are not affected. This setting is most useful in [managed settings](/en/permissions#managed-settings), where users cannot override it.

To enable [extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) in a skill, include the word "ultrathink" anywhere in your skill content.

To request deeper reasoning when a skill runs, include `ultrathink` anywhere in the skill content. See [Use ultrathink for one-off deep reasoning](/en/model-config#use-ultrathink-for-one-off-deep-reasoning).

### Run skills in a subagent

@@ -495,13 +498,13 @@ Create the Skill directory:

mkdir -p ~/.claude/skills/codebase-visualizer/scripts

```

Create `~/.claude/skills/codebase-visualizer/SKILL.md`. The description tells Claude when to activate this Skill, and the instructions tell Claude to run the bundled script:

Save this to `~/.claude/skills/codebase-visualizer/SKILL.md`. The description tells Claude when to activate this Skill, and the instructions tell Claude to run the bundled script. The script path uses [`${CLAUDE_SKILL_DIR}`](#available-string-substitutions) so it resolves correctly whether the skill is installed at the personal, project, or plugin level:

````yaml theme={null}

---

name: codebase-visualizer

description: Generate an interactive collapsible tree visualization of your codebase. Use when exploring a new repo, understanding project structure, or identifying large files.

allowed-tools: Bash(python *)

allowed-tools: Bash(python3 *)

---

# Codebase Visualizer

@@ -513,7 +516,7 @@ Generate an interactive HTML tree view that shows your project's file structure

Run the visualization script from your project root:

```bash

python ~/.claude/skills/codebase-visualizer/scripts/visualize.py .

python3 ${CLAUDE_SKILL_DIR}/scripts/visualize.py .

```

This creates `codebase-map.html` in the current directory and opens it in your default browser.

@@ -526,13 +529,13 @@ This creates `codebase-map.html` in the current directory and opens it in your d

- **Directory totals**: Shows aggregate size of each folder

````

Create `~/.claude/skills/codebase-visualizer/scripts/visualize.py`. This script scans a directory tree and generates a self-contained HTML file with:

Save this to `~/.claude/skills/codebase-visualizer/scripts/visualize.py`. This script scans a directory tree and generates a self-contained HTML file with:

- A **summary sidebar** showing file count, directory count, total size, and number of file types

- A **bar chart** breaking down the codebase by file type (top 8 by size)

- A **collapsible tree** where you can expand and collapse directories, with color-coded file type indicators

The script requires Python but uses only built-in libraries, so there are no packages to install:

The script requires Python 3 but uses only built-in libraries, so there are no packages to install:

```python expandable

#!/usr/bin/env python3

@@ -541,6 +544,7 @@ The script requires Python but uses only built-in libraries, so there are no pac

import json

import sys

import webbrowser

from html import escape

from pathlib import Path

from collections import Counter

@@ -629,7 +633,7 @@ def generate_html(data: dict, stats: dict, output: Path) -> None:

{lang_bars}

</div>

<h1>📁 {escape(data["name"])}</h1>

</div>

@@ -637,11 +641,12 @@ def generate_html(data: dict, stats: dict, output: Path) -> None:

const data = {json.dumps(data)};

const colors = {json.dumps(colors)};

function fmt(b) {{ if (b < 1024) return b + ' B'; if (b < 1048576) return (b/1024).toFixed(1) + ' KB'; return (b/1048576).toFixed(1) + ' MB'; }}

function esc(s) {{ return s.replace(/[&<>"']/g, c => ({{"&":"&","<":"<",">":">",'"':""","'":"'"}}[c])); }}

function render(node, parent) {{

if (node.children) {{

const det = document.createElement('details');

det.open = parent === document.getElementById('root');

det.innerHTML = `<summary><span class="folder">📁 ${{node.name}}</span><span class="size">${{fmt(node.size)}}</span></summary>`;

det.innerHTML = `<summary><span class="folder">📁 ${{esc(node.name)}}</span><span class="size">${{fmt(node.size)}}</span></summary>`;

const ul = document.createElement('ul'); ul.className = 'tree';

node.children.sort((a,b) => (b.children?1:0)-(a.children?1:0) || a.name.localeCompare(b.name));

node.children.forEach(c => render(c, ul));

@@ -649,7 +654,7 @@ def generate_html(data: dict, stats: dict, output: Path) -> None:

const li = document.createElement('li'); li.appendChild(det); parent.appendChild(li);

}} else {{

const li = document.createElement('li'); li.className = 'file';

li.innerHTML = `<span class="dot" style="background:${{colors[node.ext]||'#6b7280'}}"></span>${{node.name}}<span class="size">${{fmt(node.size)}}</span>`;

li.innerHTML = `<span class="dot" style="background:${{colors[node.ext]||'#6b7280'}}"></span>${{esc(node.name)}}<span class="size">${{fmt(node.size)}}</span>`;

parent.appendChild(li);

}}

@@ -670,7 +675,7 @@ if __name__ == '__main__':

To test, open Claude Code in any project and ask "Visualize this codebase." Claude runs the script, generates `codebase-map.html`, and opens it in your browser.

This pattern works for any visual output: dependency graphs, test coverage reports, API documentation, or database schema visualizations. The bundled script does the heavy lifting while Claude handles orchestration.

This pattern works for any visual output: dependency graphs, test coverage reports, API documentation, or database schema visualizations. The bundled script does the work while Claude handles orchestration.

## Troubleshooting

@@ -694,7 +699,7 @@ If Claude uses your skill when you don't want it:

Skill descriptions are loaded into context so Claude knows what's available. All skill names are always included, but if you have many skills, descriptions are shortened to fit the character budget, which can strip the keywords Claude needs to match your request. The budget scales dynamically at 1% of the context window, with a fallback of 8,000 characters.

To raise the limit, set the `SLASH_COMMAND_TOOL_CHAR_BUDGET` environment variable. Or trim the `description` and `when_to_use` text at the source: front-load the key use case, since each entry's combined text is capped at 1,536 characters regardless of budget.

To raise the limit, set the `SLASH_COMMAND_TOOL_CHAR_BUDGET` environment variable. Or trim the `description` and `when_to_use` text at the source: put the key use case first, since each entry's combined text is capped at 1,536 characters regardless of budget.

## Related resources

sub-agents +2 -2

サブエージェントの動作とセッション管理に関する記述が調整されました。

@@ -46,7 +46,7 @@ Claude delegates to Explore when it needs to search or understand a codebase wit

When invoking Explore, Claude specifies a thoroughness level: **quick** for targeted lookups, **medium** for balanced exploration, or **very thorough** for comprehensive analysis.

A research agent used during [plan mode](/en/common-workflows#use-plan-mode-for-safe-code-analysis) to gather context before presenting a plan.

A research agent used during [plan mode](/en/permission-modes#analyze-before-you-edit-with-plan-mode) to gather context before presenting a plan.

- **Model**: Inherits from main conversation

- **Tools**: Read-only tools (denied access to Write and Edit tools)

@@ -217,7 +217,7 @@ The following fields can be used in the YAML frontmatter. Only `name` and `descr

| `memory` | No | [Persistent memory scope](#enable-persistent-memory): `user`, `project`, or `local`. Enables cross-session learning |

| `background` | No | Set to `true` to always run this subagent as a [background task](#run-subagents-in-foreground-or-background). Default: `false` |

| `effort` | No | Effort level when this subagent is active. Overrides the session effort level. Default: inherits from session. Options: `low`, `medium`, `high`, `xhigh`, `max`; available levels depend on the model |

| `isolation` | No | Set to `worktree` to run the subagent in a temporary [git worktree](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees), giving it an isolated copy of the repository. The worktree is automatically cleaned up if the subagent makes no changes |

| `isolation` | No | Set to `worktree` to run the subagent in a temporary [git worktree](/en/worktrees), giving it an isolated copy of the repository. The worktree is automatically cleaned up if the subagent makes no changes |

| `color` | No | Display color for the subagent in the task list and transcript. Accepts `red`, `blue`, `green`, `yellow`, `purple`, `orange`, `pink`, or `cyan` |

| `initialPrompt` | No | Auto-submitted as the first user turn when this agent runs as the main session agent (via `--agent` or the `agent` setting). [Commands](/en/commands) and [skills](/en/skills) are processed. Prepended to any user-provided prompt |

tools-reference +1 -1

ツール参照セクション内のリンクが、新しいドキュメント構造に合わせて更新されました。

@@ -21,7 +21,7 @@ To add custom tools, connect an [MCP server](/en/mcp). To extend Claude with reu

| `CronList` | Lists all scheduled tasks in the session | No |

| `Edit` | Makes targeted edits to specific files | Yes |

| `EnterPlanMode` | Switches to plan mode to design an approach before coding | No |

| `EnterWorktree` | Creates an isolated [git worktree](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) and switches into it. Pass a `path` to switch into an existing worktree of the current repository instead of creating a new one. Not available to subagents | No |

| `EnterWorktree` | Creates an isolated [git worktree](/en/worktrees) and switches into it. Pass a `path` to switch into an existing worktree of the current repository instead of creating a new one. Not available to subagents | No |

| `ExitPlanMode` | Presents a plan for approval and exits plan mode | Yes |

| `ExitWorktree` | Exits a worktree session and returns to the original directory. Not available to subagents | No |

| `Glob` | Finds files based on pattern matching | No |

vs-code +22 -6

VS Code連携時の設定方法や、拡張機能としての使い勝手に関する解説が強化されました。

@@ -74,7 +74,7 @@ The prompt box supports several features:

- **Permission modes**: click the mode indicator at the bottom of the prompt box to switch modes. In normal mode, Claude asks permission before each action. In Plan mode, Claude describes what it will do and waits for approval before making changes. VS Code automatically opens the plan as a full markdown document where you can add inline comments to give feedback before Claude begins. In auto-accept mode, Claude makes edits without asking. Set the default in VS Code settings under `claudeCode.initialPermissionMode`.

- **Command menu**: click `/` or type `/` to open the command menu. Options include attaching files, switching models, toggling extended thinking, viewing plan usage (`/usage`), and starting a [Remote Control](/en/remote-control) session (`/remote-control`). The Customize section provides access to MCP servers, hooks, memory, permissions, and plugins. Items with a terminal icon open in the integrated terminal.

- **Context indicator**: the prompt box shows how much of Claude's context window you're using. Claude automatically compacts when needed, or you can run `/compact` manually.

- **Extended thinking**: lets Claude spend more time reasoning through complex problems. Toggle it on via the command menu (`/`). Claude's reasoning appears in the conversation as collapsed blocks: click a block to read it, or press `Ctrl+O` to expand or collapse every thinking block in the session. See [Extended thinking](/en/common-workflows#use-extended-thinking-thinking-mode) for details.

- **Multi-line input**: press `Shift+Enter` to add a new line without sending. This also works in the "Other" free-text input of question dialogs.

### Reference files and folders

@@ -94,7 +94,7 @@ You can also hold `Shift` while dragging files into the prompt box to add them a

### Resume past conversations

Click the **Session history** button at the top of the Claude Code panel to access your conversation history. You can search by keyword or browse by time (Today, Yesterday, Last 7 days, etc.). Click any conversation to resume it with the full message history. New sessions receive AI-generated titles based on your first message. Hover over a session to reveal rename and remove actions: rename to give it a descriptive title, or remove to delete it from the list. For more on resuming sessions, see [Common workflows](/en/common-workflows#resume-previous-conversations).

### Resume remote sessions from Claude.ai

@@ -209,13 +209,27 @@ These are VS Code commands for controlling the extension. Not all built-in Claud

The extension registers a URI handler at `vscode://anthropic.claude-code/open`. Use it to open a new Claude Code tab from your own tooling: a shell alias, a browser bookmarklet, or any script that can open a URL. If VS Code isn't already running, opening the URL launches it first. If VS Code is already running, the URL opens in whichever window is currently focused.

Invoke the handler with your operating system's URL opener. On macOS:

Invoke the handler with your operating system's URL opener.

```bash

```bash theme={null}

open "vscode://anthropic.claude-code/open"

```

Use `xdg-open` on Linux or `start` on Windows.

```bash theme={null}

xdg-open "vscode://anthropic.claude-code/open"

```

In PowerShell:

```powershell theme={null}

Start-Process "vscode://anthropic.claude-code/open"

```

In `cmd.exe`, `start` treats its first quoted argument as a window title, so pass an empty title before the URL:

```cmd theme={null}

start "" "vscode://anthropic.claude-code/open"

```

The handler accepts two optional query parameters:

@@ -230,6 +244,8 @@ For example, to open a tab pre-filled with "review my changes":

vscode://anthropic.claude-code/open?prompt=review%20my%20changes

```

To launch a terminal session instead of a VS Code tab, use the CLI's `claude-cli://` handler. See [Launch sessions from links](/en/deep-links).

## Configure settings

The extension has two types of settings:

@@ -336,7 +352,7 @@ Use the `--worktree` (`-w`) flag to start Claude in an isolated worktree with it

claude --worktree feature-auth

```

Each worktree maintains independent file state while sharing git history. This prevents Claude instances from interfering with each other when working on different tasks. For more details, see [Run parallel sessions with Git worktrees](/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees).

## Use third-party providers

zero-data-retention +1 -1

データ保持ゼロポリシーに関するリンクが最新のドキュメント構成に合わせて修正されました。

@@ -16,7 +16,7 @@ ZDR on Claude for Enterprise gives enterprise customers the ability to use Claud

- [Server-managed settings](/en/server-managed-settings)

- Audit logs

ZDR for Claude Code on Claude for Enterprise applies only to Anthropic's direct platform. For Claude deployments on AWS Bedrock, Google Vertex AI, or Microsoft Foundry, refer to those platforms' data retention policies.

ZDR for Claude Code on Claude for Enterprise applies only to Anthropic's direct platform. For Claude deployments on Amazon Bedrock, Google Vertex AI, or Microsoft Foundry, refer to those platforms' data retention policies.

## ZDR scope