Browse the reference ⌄
Implementation Guide published

Coding-Agent Workstation Baseline (Claude Code)

Put Claude Code on developer workstations and build agents as privileged automation: one device-delivered managed policy per surface, lock flags that stop rules merging upward, command hooks for enforcement and HTTP hooks only for evidence, the OS sandbox where it runs, telemetry by policy, and the workstation recorded as a processing location. Dated to November 2026.

Version
0.1.0
Owner
DEIXEI
Last reviewed
Reading time
59 min

For Cto · Ai Architect · Platform Engineer · Security Engineer · Soc · Risk And Assurance · Internal Audit · Data Protection

Sources and details
Source works
Book 3 · Research Series
Source chapters
5, 6, 8, 9, 10, 12
Source appendices
04:B
Refresh trigger
vendor release

Full source list ↓ Source index →

A coding agent on a developer workstation reads the repository, runs shell commands with the developer’s privileges, edits code and calls external tools. Treat it as privileged automation with its own identity, policy and telemetry, not as a chat assistant with a terminal. The workstation is the least production-like place an agent runs, which is why it is the place most often left ungoverned. Distance from production does not remove the path to production.

This page is deliberately vendor-specific. It sets out a baseline for Claude Code on a Microsoft-managed Windows estate with WSL2, Linux workstations and hosted CI. The generic principle, that a client-side setting is never the enforcement boundary, is on identity and secrets. MCP server admission is on the connector broker. Model allow-lists and version pinning are governed on model governance.

How to read the vendor facts on this page

Settings keys, paths, flags and version numbers change with almost every release. Research Paper 3 records three releases in the five days before its check. Every vendor statement here carries its date and source.

MarkerMeaning
Per WP3 (10 Nov 2026)Research Paper 3, Securing Claude Code in the Enterprise. Its author verified it against the Claude Code documentation as served on 10 November 2026 (changelog head: version 2.1.322). The paper notes that the documentation was checked, not a running binary. This is the primary source for this page, and wins where it conflicts with Book 3.
Per Book 3 Ch 8 (Aug 2026) or App B (May 2026)Deploying Claude Safely. These facts are older and were not re-verified by WP3. They carry a [FACT-CHECK: …] marker.
RecommendationA design choice made by this page or by the cited author. It is not a vendor statement.
Bank ABank A is a composite example from Book 3, not a real institution. Its numbers are illustrative.

WP3 itself labels its baseline policy, split pipeline, monitors and roadmap as untested design proposals. This page inherits that status. Regulatory article mapping and dates are kept on the regulatory map and are not restated here.

The baseline in one table

WP3 §3.3 names four layers of defence (identity, policy, runtime, observability) and trusts none of them alone. This page splits network and data out of the runtime layer as a fifth row, because it has different owners.

LayerWhat it decidesPrimary mechanismOwnerWhat it cannot do
Identity and tenancyWho may call which model endpoint, under which contractSSO into the firm’s Claude organisation; login and provider pinned by device policy; workload credentials for pipelinesIdentity engineeringGovern a developer who calls the API from another tool
Managed policyWhat the agent may doOne version-controlled managed settings document, locked with the allowManaged*Only flags, plus managed hooksSecurity engineering (content); platform (delivery)Resist a local administrator or a modified client
Runtime isolationWhat the operating system lets spawned commands touchClaude Code sandbox (bubblewrap on Linux/WSL2, Seatbelt on macOS); dev containers for high-risk repositoriesPlatform engineeringCover file tools, MCP servers or hooks, or run on native Windows
Network and dataWhere traffic may go, what leaves, what is kept locallyEgress allow-list at firewall or web gateway; Tenant Restrictions; secret placement; local retentionNetwork and data protectionInspect prompt content inside the TLS session to the model endpoint
Monitoring and evidenceWhat can be seen and proved afterwardsOpenTelemetry export set by policy; hook events to the SIEM; host process telemetry as the independent recordSOC and security engineeringProve anything the user’s own client could have fabricated, without host corroboration

Why the settings file is not the boundary

The vendor says so

Per WP3 §3.3 (10 Nov 2026), Anthropic’s documentation describes server-managed settings as a client-side control and not a security boundary. A developer who is a local administrator can edit the managed source. A user running a modified client can bypass any client-side control. Managed settings bind only Claude Code, so a developer calling the API from another tool is outside them. The permission engine runs as configuration inside the process it constrains. Every high-risk context therefore needs an operating-system or network control behind the policy file.

Threats the baseline is built against (WP3 §3.2)

#ThreatTypical vectorMain controls on this page
T1Indirect prompt injectionInstructions in a README, dependency, web page, ticket or MCP responseSandbox with no unsandboxed retry; WebFetch denied; MCP lock; review of agent output
T2Leakage to the model endpointSource, secrets or client data sent to an unapproved endpoint or personal accountLogin and provider pinning; Tenant Restrictions; repository tiering
T3Over-privileged executionBypass mode, broad allow rules, approval fatigueBypass mode disabled; managed-only rules; auto-mode decision
T4Secrets in reach.env, ~/.ssh, cloud CLI caches, kubeconfigRead deny rules + sandbox read restrictions + short-lived credentials
T5Malicious MCP server, hook or pluginUnvetted extensionsallowManagedHooksOnly, MCP allow-list by URL/command, plugin locks, sideload flags
T6Shadow usagePersonal accounts, unmanaged keysDevice-delivered login keys; identity monitors; Tenant Restrictions
T7CI/CD abuseA pull request steers an agent holding pipeline credentialsCI profile in the image; split pipeline; no privileged credential in the agentic stage
T8Configuration tamperingA user weakens local policyNo local admin; ConfigChange hook; source-drift and telemetry-gap monitors

Rule matching has documented limits. A deny for curl does not match /usr/bin/curl or sh -c 'curl …'. WP3 cites a March 2026 third-party test (Ona) in which an agent reached a denied binary through /proc/self/root/…. The bubblewrap sandbox stopped it. The agent then asked to run the command unsandboxed, and only the human prompt held. The baseline removes that retry route by setting allowUnsandboxedCommands: false.

Guidance versus control: sort every policy line

Book 3 Ch 8 §4.1 divides the surfaces on which a firm can express policy into two columns. The division rests on Anthropic’s June 2026 description of its steering mechanisms. Only two surfaces enforce: managed settings and hooks. CLAUDE.md, .claude/rules/, skills, subagent definitions, output styles and system-prompt additions steer the model, and the model can fail to follow them. The permissions documentation says the same: permission rules are enforced by Claude Code, and prompt or CLAUDE.md instructions do not change what Claude Code allows.

Seven surfaces express policy, but only two of them are controls: prompted guidance is probabilistic, hooks and managed settings are deterministic.

Guidance steers the model; only managed settings and hooks enforce. Source: Deploying Claude Safely (Book 3), Chapter 8, Figure 8.1.

ColumnSurfacesCounts in the RCSA as
ControlManaged settings (with lock flags); managed hooks; OS sandbox; network egressPreventive or detective control
GuidanceRepository CLAUDE.md, rules, skills, subagents, output stylesTraining or awareness measure only

Rule (Book 3 Ch 8 §4.1; adopted here). A risk-and-control self-assessment must not carry a control assertion sourced from the guidance column. “Our CLAUDE.md forbids touching production configuration” is a training statement. Book 3 also notes that a developer can skip a repository CLAUDE.md through claudeMdExcludes, while a CLAUDE.md delivered by device management cannot be excluded [FACT-CHECK: claudeMdExcludes behaviour and the managed CLAUDE.md location, as of Aug 2026]. Acceptance check: for each control assertion about Claude Code, name the mechanism that enforces it. If the answer is “the model reads the file”, move the assertion to the training column or move the policy into settings or a hook.

Step 1 — Choose the identity route and pin it

Approved routes (per WP3 §4.1, 10 Nov 2026)

RouteAuthenticationSuitsNotes
Claude for EnterpriseSSO into the firm’s Claude organisationInteractive developer useSSO, domain capture, SCIM, audit logs, Compliance API, server-managed settings
Claude for TeamsSSOSmaller groupsSSO and server-managed settings; no SCIM, domain capture, audit logs or Compliance API
Claude API (Console)API key or OAuth profile in a Console organisationPipelines, servicesA Console organisation is separate from the claude.ai organisation; settings and audit do not cross over
Claude in Microsoft FoundryEntra ID or API key against the firm’s Azure resourceAzure-native pipelinesSee the hosting facts below
LLM gateway in front of any routeGateway-issued credentialCentral policy, inspectionServer-managed settings are not fetched on this route

Foundry facts that are often misreported (per WP3 §4.1, which cites Microsoft Learn articles dated June–September 2026 and Anthropic pages, all accessed 10 November 2026). Microsoft offers each Claude model in up to two versions: “hosted on Azure” and “hosted on Anthropic infrastructure”, and the second may process data outside the selected Azure geography. The hosting option is chosen per deployment. On the day WP3 checked, the newest model families were Anthropic-hosted only. Deployment types are Global Standard and Data Zone Standard (US), and the data zone exists only for Azure-hosted versions. There is no EU data zone. On both options Anthropic is the seller and operator and an independent data processor. WP3 found no zero-data-retention option documented for the Foundry route. The data residency and processor consequences belong on data classes and lanes and the third-party register.

Amazon Bedrock and Google Cloud routes (per WP3 §4.3, which rests on Anthropic’s provider pages only; AWS and Google documentation was not opened).

PropertyAmazon BedrockGoogle Cloud (Agent Platform, formerly Vertex AI)
SwitchCLAUDE_CODE_USE_BEDROCK=1 plus the AWS credential chainCLAUDE_CODE_USE_VERTEX=1 plus project ID and region
PeopleIAM Identity Center profilesApplication Default Credentials
WorkloadsInstance or task roles; short-term Bedrock API keys only where no role is availableService accounts or certificate-based Workload Identity Federation
Permissionsbedrock:InvokeModel, bedrock:InvokeModelWithResponseStream, bedrock:ListInferenceProfiles, bedrock:GetInferenceProfileroles/aiplatform.user (Book 3 Ch 8 §7.1 names the permission aiplatform.endpoints.predict)
EU residencyCross-region inference profiles with an eu. prefixeu multi-region or a single European region
Extras and gapsGuardrails on the request path; WebSearch unavailable—

Both routes share three gaps: no server-managed settings, no user email in telemetry (Step 9), and model aliases that resolve to provider defaults which can lag the newest release, so pin versions. The pipeline identity pattern is the same on all three clouds: a workload role, never a stored key. [FACT-CHECK: IAM action names, role names and eu. profile availability against current AWS and Google documentation.]

Identity rules (per WP3 §4.2, 10 Nov 2026)

  1. Exclude personal accounts by setting, not by request. Set forceLoginMethod and forceLoginOrgUUID. Claude Code exits at startup if the claude.ai credential belongs to an organisation not on the list. Deliver these keys by device management: server-managed settings arrive only after the user has signed in, so they cannot redirect a first login. WP3 documents two gaps. The login screen pre-selects the method but does not enforce it. claude setup-token checks the method but not the organisation.
  2. Restrict the provider. allowedProviders lists the services the machine may reach Claude through. Other providers are refused at startup. WP3 gives the minimum version as 2.1.285.
  3. SSO and SCIM before rollout, so access follows joiner–mover–leaver.
  4. No raw API keys on endpoints. With both login keys deployed, sessions that authenticate with ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN or apiKeyHelper are blocked at startup. The interactive profile therefore cannot be reused on build agents; see the CI profile below.
  5. One route per use case, written down.
  6. Know where server-managed settings stop. Claude Code skips the server-managed fetch whenever a cloud-provider variable or a non-default ANTHROPIC_BASE_URL is set. On any gateway, Bedrock, Google Cloud or Foundry route, the device-delivered policy is the only policy.

Credential precedence is the bypass surface

Per Book 3 Ch 5 §4.2 (Aug 2026), Claude Code resolves credentials in this order [FACT-CHECK: current order in the Claude Code authentication documentation]:

  1. a signed-in gateway session (above everything else);
  2. cloud-provider variables CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX or CLAUDE_CODE_USE_FOUNDRY;
  3. ANTHROPIC_AUTH_TOKEN;
  4. ANTHROPIC_API_KEY;
  5. apiKeyHelper;
  6. CLAUDE_CODE_OAUTH_TOKEN;
  7. subscription OAuth.

If a developer exports one of these variables, the session changes identity, billing account and policy channel. The controls are:

  • route and provider variables only in the managed env block, never in the shell;
  • allowedProviders set to the firm’s provider;
  • the login keys, which block environment credentials on the interactive profile.

Organisation pinning and a vault-helper key are mutually exclusive on the Anthropic API path. If the firm wants vault-issued credentials and organisation pinning together, the options are workload federation, the Claude apps gateway or cloud IAM. Setting both keys does not work. A workload whose federated token cannot be obtained must fail with an audit record. It must not fall back silently to a forgotten API key.

Where the Claude apps gateway fits

Per Book 3 Ch 6 §5.2, Anthropic shipped a self-hosted Claude apps gateway in June 2026 [FACT-CHECK: product status, configuration keys and supported upstreams as of Nov 2026]. It provides OIDC sign-in (SAML and LDAP are not supported), per-user spend caps and ordered upstream failover. It enforces model allow-lists server-side and blocks sessions at startup if the gateway is unreachable. WP3 §4.2 says it supplies remote settings delivery for cloud-provider routes, and that WP3 did not evaluate it.

Scope limit (Book 3). The apps gateway fronts Claude Code only. It has no DLP, tokenisation or policy-decision call-out, it disables WebSearch, and it has no service-token flow for CI. Use it for the developer credential boundary. Keep the general-purpose model gateway (APIM or equivalent) for anything that touches institutional data. A pipeline still authenticates against the provider directly with a workload identity.

Step 2 — Deliver one managed policy per surface

Settings scopes and how permission rules combine

Per WP3 §5.1, managed settings rank above user, project and local settings and above a --settings value. Nothing in lower files overrides a managed key, except a small set of restrictive keys where a stricter value from a lower level is still honoured. Book 3 App B §2 sets out the full five scopes, highest first:

  1. managed;
  2. command-line arguments;
  3. .claude/settings.local.json (git-ignored);
  4. .claude/settings.json (committed);
  5. ~/.claude/settings.json.

Permission rules merge across scopes rather than replace one another, and a deny at any level wins. That behaviour suits denies. For allows it is a trap. A developer’s settings.local.json allow combines with the managed floor until allowManagedPermissionRulesOnly is set (see the lock flags below).

Delivery mechanisms per OS (per WP3 §5.1, 10 Nov 2026)

MechanismLocationWhen read
Server-managedclaude.ai admin console; cached locallyAt startup; polled hourly
MDM / OS policyWindows: REG_SZ or REG_EXPAND_SZ value named Settings under HKLM\SOFTWARE\Policies\ClaudeCode, holding the JSON. macOS: managed-preferences domain com.anthropic.claudecodeAt startup; re-checked every 30 minutes
Filemanaged-settings.json plus optional managed-settings.d/*.json in C:\Program Files\ClaudeCode\ (Windows), /etc/claude-code/ (Linux and WSL), /Library/Application Support/ClaudeCode/ (macOS)At startup; reloaded on change
User registrySettings under HKCU\SOFTWARE\Policies\ClaudeCodeOnly when no administrator source is present

The old Windows path C:\ProgramData\ClaudeCode\ is no longer read. Drop-in files merge alphabetically: lists combine and later single values win. A managed file that is present but contains invalid JSON stops Claude Code from starting. Validate the document in the deployment pipeline before it ships.

The sources do not merge: choose one

Per WP3 §5.1, by default Claude Code uses the highest-ranked source that delivers at least one policy key, in the order server-managed → MDM → file → user registry. It ignores the rest without warning. Some keys are read from every administrator source regardless: the sandbox locks, the MCP allow-list lock, deniedMcpServers, forceRemoteSettingsRefresh and, from 2.1.223, the env block merged per variable. Login keys are taken from the device policy ahead of the server.

The failure mode is easy to miss. One key saved in the admin console silently displaces the whole device policy.

Recommendation (WP3; adopted here).

  • On managed devices, make the device-delivered policy the only policy. Leave the console’s managed settings empty, or use them only for populations without device management.
  • If server-managed settings are also needed (cloud sessions do not read device policy), set managedSourcesBehavior: "merge" in the highest-ranked source (2.1.242+). Treat both sources as one controlled document. Under merge, locks take the strictest value and lists combine.
  • Confirm on each surface with /status, whose Setting sources line names the source in use, and with claude doctor. Across the fleet, the managed_settings_resolved telemetry event (2.1.274+) reports the same thing.

Consequence for cohort fragments (inference from WP3 §5.1–5.2; test before relying on it). On Windows the HKLM registry value outranks the file source. A cohort drop-in placed in C:\Program Files\ClaudeCode\managed-settings.d\ beside a registry policy would therefore be ignored, apart from the always-read keys. Book 3 App B §3.2 points the same way from another angle: it supports the drop-in directory on the file route only, not on the registry route. On the registry route, deliver one complete policy document per device group (repository tier or cohort). Keep the tier documents generated from a common base in version control. Drop-ins remain usable on Linux file delivery and inside images.

Per surface

SurfaceChannelSpecifics
Windows 11, Windows 365, personal AVDIntune configuration writing the HKLM Settings valueNeeds admin rights to write. Anthropic publishes Intune, Group Policy and Jamf templates (per WP3). If a file is preferred, an Intune Remediation re-asserts its hash and ACL on a schedule
WSL2 on a Windows hostThe Windows policy, inheritedPer WP3 §7.1, /etc/claude-code inside WSL is user-writable: the developer controls the distribution, so a file there is not an administrator source. Set wslInheritsWindowsSettings: true in the HKLM policy or in a file under C:\Program Files\ClaudeCode\ (2.1.282+). WSL then reads the Windows chain, and reads /etc/claude-code only when no Windows administrator document exists
Linux workstationConfiguration management places /etc/claude-code/managed-settings.json, root-ownedInstall from Anthropic’s signed apt repository or an internal mirror. Package-manager installs do not self-update
macOSMDM profile for com.anthropic.claudecode, or the file pathSeatbelt sandbox is built in
Multi-session AVDAs Windows, strictest tierSee the shared-host notes below
Build agentPolicy baked into the image’s system directorySee the CI profile

Use the Intune Windows Subsystem for Linux settings to disable WSL1 and the inbox WSL version, and to remove user control of kernel, networking and firewall configuration (per WP3 §7.1, citing Microsoft’s Intune WSL page, Oct 2026). The sandbox requires WSL2.

Source conflict — Book 3 Appendix B §3.2–3.3 (May 2026) versus WP3 (Nov 2026). Appendix B gives the Windows registry path as HKEY_LOCAL_MACHINE\SOFTWARE\Anthropic\ClaudeCode\Settings. It says “registry takes precedence if both present”. It also treats /etc/claude-code/managed-settings.json inside WSL2 as the governing administrator floor. WP3, verified later against the documentation, gives HKLM\SOFTWARE\Policies\ClaudeCode. It shows that sources do not merge (the first source with any key wins, silently), and that /etc/claude-code is user-writable on WSL. This page follows WP3. Book 3 Chapter 8 §4.2 (August 2026) already uses the Policies path and wslInheritsWindowsSettings. The Appendix B error is recorded for correction in the manuscript.

Fail-closed settings fetch

Book 3 App B Block 1 and Ch 8 §4.3 set forceRemoteSettingsRefresh: true. Per Book 3, this setting blocks startup until managed settings have been freshly fetched, and exits if the fetch fails. WP3 confirms that the key is read from every administrator source. Use it where server-managed settings are part of the design: merge mode, or a population without device management. In that case a session that cannot fetch policy should not run on stale or absent policy.

Do not rely on App B’s rationale as written. App B says that without the key “an offline workstation falls back to user scope”. WP3 instead describes a device policy that stays in force regardless of the server. Under this page’s single-source recommendation (device policy only, console empty), the key’s effect needs testing [FACT-CHECK: forceRemoteSettingsRefresh behaviour when the console holds no managed settings, and its interaction with device-delivered policy].

Step 3 — Ship the baseline policy

The base document (per WP3 §5.2, 10 Nov 2026)

This is WP3’s Linux and WSL2 profile for interactive use on the Enterprise route, delivered through the Windows HKLM policy with WSL inheritance or as the Linux file. It is reproduced as configuration. Replace the placeholders.

{
  "forceLoginMethod": "claudeai",
  "forceLoginOrgUUID": ["00000000-0000-0000-0000-000000000000"],
  "allowedProviders": ["anthropic"],
  "requiredMinimumVersion": "2.1.302",
  "permissions": {
    "defaultMode": "default",
    "disableBypassPermissionsMode": "disable",
    "blockReadsOutsideWorkingDirectories": true,
    "deny": [
      "Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)",
      "Read(~/.ssh/**)", "Read(~/.azure/**)", "Read(~/.aws/**)", "Read(~/.kube/**)",
      "Bash(curl *)", "Bash(wget *)", "WebFetch", "WebSearch"
    ]
  },
  "allowManagedPermissionRulesOnly": true,
  "allowManagedHooksOnly": true,
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [ { "serverUrl": "https://mcp.example.internal/*" } ],
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true,
    "allowUnsandboxedCommands": false,
    "network": {
      "allowedDomains": ["packages.example.internal"],
      "allowManagedDomainsOnly": true
    }
  },
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "grpc",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "http://127.0.0.1:4317",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  },
  "cleanupPeriodDays": 14
}
GroupKeysWhat it does (per WP3)
Login and providerforceLoginMethod, forceLoginOrgUUID, allowedProvidersFirm organisation and provider only; see Step 1
Version floorrequiredMinimumVersionRead only from managed settings. Older clients exit at startup. WP3 chose 2.1.302 because from that version non-interactive runs with no mode set start in Manual mode, and it is above every other key’s minimum
Modespermissions.defaultMode: "default", permissions.disableBypassPermissionsMode: "disable"Sessions start in Manual mode; bypass mode removed
File reachpermissions.blockReadsOutsideWorkingDirectories, Read deniesFile tools refuse reads outside working directories (cross-scope from 2.1.257). ~/ is home-relative, ./ is working-directory-relative, and an absolute path needs //
LocksallowManagedPermissionRulesOnly, allowManagedHooksOnly, allowManagedMcpServersOnlyManaged rules, hooks and MCP allow-list are the only ones. Rules from user/project/local files and --allowedTools are ignored
Sandboxsandbox.*Sandbox on (off by default). Refuses to start where the sandbox cannot run. No retry outside the sandbox. Only managed domains, without prompting
Telemetryenv blockOTel export to a local receiver. A managed env value overwrites the user’s shell export
RetentioncleanupPeriodDaysLocal transcript retention; default 30, minimum 1

Variants (per WP3 §5.2).

  • Native Windows: the sandbox does not run, so failIfUnavailable would stop Claude Code starting (see Step 6 for the decision).
  • Repository tiers: deliver a different document to a different device group. Lower tiers may re-allow WebFetch for named documentation domains.
  • Build agents: see the CI profile.

Regulated-tier overlay (Book 3 additions, not re-verified by WP3)

Book 3 Ch 8 §4.3–§7 and PR-2 (August 2026) add controls that WP3’s base document does not set. WP3 mentions some of them and deliberately leaves them as decisions for the firm. Hold them as a separate, reviewable layer: a drop-in on file delivery, or merged into the tier document on registry delivery. Do not blend them silently into the base. Every key below is [FACT-CHECK: key name, placement (top level or under permissions/sandbox) and minimum version against the Claude Code settings reference, as of Nov 2026].

{
  // Sideload closure (Book 3 Ch 8 §4.3). WP3 lists the plugin locks and leaves them to the firm.
  "strictPluginOnlyCustomization": true,
  "disableSideloadFlags": true,
  "strictKnownMarketplaces": [ { "hostPattern": "^git\\.example\\.internal$" } ],

  // Model gating (Book 3 Ch 8 §4.3; v2.1.175+ per Book 3). Full IDs, not aliases.
  "availableModels": ["<full-approved-model-id>", "<full-approved-model-id>"],
  "enforceAvailableModels": true,

  // Autonomy (Book 3 Ch 8 §4.5) — per-tier decision, see Step 4.
  "disableWorkflows": true,

  // Bound HTTP hooks from every source (Book 3 Ch 8 §5.2).
  "allowedHttpHookUrls": ["https://siem-ingest.example.internal/claude/*"],
  "httpHookAllowedEnvVars": ["SIEM_TOKEN"],

  // Sandbox read and socket restrictions (App B Block 5; Ch 8 §6.2).
  "sandbox": {
    "filesystem": {
      "allowManagedReadPathsOnly": true,
      "denyRead": ["~/.ssh", "~/.aws", "~/.kube"]
    },
    "network": { "strictAllowlist": true },
    "allowUnixSockets": false
  },

  // Retention and feedback (Ch 8 §7; 7 days is the composite Bank A value).
  "cleanupPeriodDays": 7,
  "env": { "DISABLE_FEEDBACK_COMMAND": "1" }
}

On drop-in merge semantics, WP3 says that lists combine and later single values win. Book 3 App B adds that objects deep-merge. Check the merged result with /status and /permissions rather than predicting it.

Lock flags and sideload closure

The three allowManaged*Only flags turn the managed tier from a starting point into a floor. Without them, permission rules and the MCP allow-list merge upward from user files.

FlagClosesNote
allowManagedPermissionRulesOnlyA developer broadening permissions in settings.local.json, ~/.claude/settings.json or --allowedToolsClaude Code also stops offering to save “always allow” answers (WP3)
allowManagedHooksOnlyReplacing the audit hook with a no-op; adding an exfiltrating hookPer Book 3, a user or project disableAllHooks cannot touch a managed hook [FACT-CHECK]
allowManagedMcpServersOnlyDeveloper-added MCP serversIndependent of the rules flag. allowManagedPermissionRulesOnly does not enforce the MCP allow-list. Book 3 calls this the commonest mis-assumption it meets
strictPluginOnlyCustomizationSkills, agents, hooks and MCP servers arriving from user or project sourcesBook 3 Ch 8 §4.3 [FACT-CHECK]
disableSideloadFlags--plugin-dir, --plugin-url, --agents, --mcp-config at start-upPer Book 3, without it marketplace policy can be bypassed for a single run [FACT-CHECK]

Verification (Book 3 Ch 8 §9). Run /permissions on a sample of workstations and read the source column. Any rule sourced from user settings proves that the lock is missing. After fixing, re-sample weekly for one quarter.

Permission-rule authoring standard

Evaluation order, per Book 3 Ch 8 §4.4: deny, then ask, then allow; first match wins; specificity does not reorder. A bare tool name used as a deny ("WebFetch") removes the tool from the model’s context entirely. That reduces the attack surface, not only the runtime outcome.

The rules this page adopts:

  1. Whole-command denies, not argument-constraining allows. Write Bash(curl *), not Bash(curl http://github.com/ *). The vendor calls argument patterns fragile: options before the URL, protocol changes, redirects, shell variables and doubled spaces all defeat them. Put real command parsing in a PreToolUse command hook.
  2. Never allow-list an environment runner. npx, docker exec, devbox run and similar pass the rest of the command through. Bash(devbox run *) authorises everything after run. Allow the named inner commands instead, and deny the pass-through forms.
  3. Path rules only on Read and Edit. Per Book 3 Ch 8 §4.4, rules written against Write, MultiEdit, Glob or NotebookEdit with a path are accepted but never consulted [FACT-CHECK]. A Write(**/.git/config) rule does nothing, so use Edit(**/.git/config).
  4. Anchor paths correctly. Use ~/ for home, ./ for the working directory and // for an absolute filesystem path, for example Read(//mnt/c/**) in WSL. A single leading slash anchors at the settings source, not the filesystem root (WP3 §7.2).
  5. Do not rely on denies for subprocesses. Read denies cover the file tools and the file commands Claude Code recognises in a shell line. They do not cover arbitrary subprocesses that open files themselves. The sandbox carries the Read deny paths to sandboxed commands (WP3 §5.2).
  6. WebFetch alone does not stop network access. If Bash is allowed, curl or any other client can reach the URL. Network control is the sandbox proxy and the egress allow-list.
  7. There is no .claudeignore. The documentation says such a file has no effect (WP3 §9.2). Exclude files with Read denies.

Source conflict — Book 3 Appendix B Block 7. The appendix’s deny list includes Write(**/.git/config), Write(/etc/**) and Write(/usr/**). By Book 3 Chapter 8’s own later rule, these are never consulted. It also uses Bash(curl http*), an argument-constraining pattern. This page follows Chapter 8 and WP3: whole-command denies, Edit/Read path rules only.

Why the deny list stays at all (WP3 §5.2). It removes the easy cases and produces a telemetry signal when it fires. The file is built so that it does not rest on the denies. The sandbox and the egress allow-list carry the weight.

Model gating

availableModels is the enterprise model allow-list. Per Book 3 Ch 8 §4.3, used alone it leaks by design: the picker’s “Default” entry resolves to the account’s runtime default, which may sit outside the list. enforceAvailableModels: true (v2.1.175+ per Book 3) closes the leak. Book 3’s composite Bank A shipped the list without the flag. During cohort 1, four engineers on “Default” resolved to an unapproved model for a week, and the model usage registry detected it before anyone reported it.

Pin full model IDs, not the floating sonnet/opus/haiku aliases, whenever the register has to name a version. Aliases resolve to per-provider defaults that move on the provider’s schedule. Per Book 3 Ch 8 §7.1, the server-enforced model restriction on Claude Enterprise does not apply on Bedrock or Google routes. There, availableModels plus enforceAvailableModels is client-side software on an endpoint the user controls. The registry, alias-drift and upgrade lifecycle live on model governance.

Source difference. Book 3 App B Block 6 (May 2026) uses aliases (["sonnet", "haiku"]), gates Opus through a cohort fragment, and sets alwaysThinkingEnabled: false. Book 3 Ch 8 (August 2026) pins full IDs and adds enforceAvailableModels. This page follows Chapter 8. Cohort gating stays valid. On registry delivery, implement it as a tier document, not as a drop-in.

Step 4 — Decide the autonomy defaults before rollout

DecisionFactsOptionsThis page’s recommendation
Auto mode (a classifier model approves actions)Per WP3 §5.2: from 2.1.283 it is the built-in starting mode for interactive sessions on every plan and provider. Explicit ask and deny rules still apply. A disableAutoMode control set to "disable" exists, but WP3 found the pages inconsistent about whether it sits at the top level or under permissions, so WP3 leaves it out(a) Start sessions in Manual (defaultMode: "default") but leave auto mode selectable; (b) disable it; (c) allow it only inside a sandbox or containerManual mode outside a sandbox for regulated tiers; auto mode only inside a sandbox or dev container, after a pilot (WP3 author’s judgement). Book 3 Ch 8 §4.4 adds a caution: banning auto mode without reducing prompt volume pushes engineers towards bypass. Its composite Bank A disables auto mode in production repositories, allows it in the sandboxed development estate, and reviews quarterly [FACT-CHECK: disableAutoMode placement]
Bypass modeThe vendor reserves it for isolated containers or VMs without internet access, and says it offers no protection against prompt injection. Claude Code refuses bypass mode as root or under sudo on Linux and macOSDisable on every managed endpointpermissions.disableBypassPermissionsMode: "disable" everywhere. In CI use dontAsk instead
Dynamic workflows (Claude writes orchestration scripts that run many parallel subagents)Per Book 3 Ch 8 §4.5 (Aug 2026): enabled by default on Team and Enterprise and disabled on Pro. Subagents nest up to five levels, and their intermediate reasoning does not reach the transcript a supervisor reads [FACT-CHECK]Leave on; disable per tier with disableWorkflows: trueDisable for repositories at the highest risk tiers until a hook-based supervision pattern exists. Book 3’s Bank A disabled them for payments and core banking only
Sandbox auto-allow vs regular permissionsAuto-allow runs sandboxed commands without prompting. Regular permissions keeps prompting inside the sandboxPer tierRegular permissions in production-adjacent repositories; auto-allow in the sandboxed development estate (Book 3 Ch 8 §6.3). On Linux, auto-allow absorbs most of the friction of locked rules (WP3)

Step 5 — Hooks: enforcement and evidence

Hooks are shell commands, or HTTP calls, that run on lifecycle events. They are the only per-action enforcement point the firm controls at the workstation, and the workstation’s evidence stream. Treat approved hooks as code: reviewed, version-controlled and deployed only through managed settings, with allowManagedHooksOnly set.

Operating semantics (per Book 3 Ch 8 §5.2 and App B §6.2)

[FACT-CHECK: all items in this table against the Claude Code hooks reference, as of Nov 2026.]

PropertyBehaviourDesign consequence
BlockingPreToolUse and ConfigChange run synchronously and the session pausesDecide locally and fast; Bank A’s hooks decide in under two seconds and emit to the SIEM asynchronously
TimeoutCh 8 gives a default of 600 seconds for command and HTTP handlers. App B writes per-hook values of 2000–5000, which suggests millisecondsConfirm the unit before copying App B’s values; a mis-read unit turns a 5-second bound into 83 minutes
Block signalExit code 2 blocks, and stderr is returned to Claude, so the block also explains itself. Exit 0 with JSON may carry permissionDecision (allow, deny, ask, defer) and rewrite arguments via updatedInputPut a policy reference in the stderr text
Malformed outputFrom v2.1.214, exit 0 with malformed JSON on PreToolUse blocksFail-closed, as wanted
PrecedenceA hook’s allow does not bypass deny or ask rules. Several hooks on one event run in parallel, and the most restrictive decision winsHooks add restrictions on top of the floor and cannot lower it
Env expansionHTTP header variables expand only if listed in allowedEnvVarsProvision the SIEM token at image bake; rotate through the secret workflow
HTTP hooks fail openA non-2xx response, a timeout or a connection failure is a non-blocking error. Only a 2xx carrying a block decision blocksEvery blocking hook is a command hook. HTTP hooks carry telemetry only. Bound them with allowedHttpHookUrls (an empty array blocks all HTTP hooks) and httpHookAllowedEnvVars, which apply to hooks from every source

The required hook bundle

Book 3 Appendix B §6.1 (May 2026) specifies six hooks. Chapter 8 §5.1 (August 2026) adds a seventh, PreCompact. This page follows Chapter 8.

#Event (matcher)TypeRoleWhat it does
1UserPromptSubmitHTTPEvidencePosts session ID, working directory and host metadata (OS, WSL2 attestation) to the SIEM. Book 3 adds an inline PII redaction pass (IBAN, email, card number) that warns rather than blocks. Prompt content in the SIEM is a works-council and DPIA decision; see Step 8
2PreToolUse (Bash)commandEnforcementParses the full command string, which the pattern matcher cannot do. Blocks rm -rf on system paths, curl/wget to domains off the allow-list, nc, /dev/tcp, reverse-shell shapes and environment runners used as pass-throughs. This is the compensating control for fragile Bash patterns
3PreToolUse (Edit; App B uses Edit|Write)commandEnforcementSensitive-file guard: **/.env*, **/secrets/**, **/keystore.*, .git/config and per-project patterns
4PreToolUse (mcp__.*)commandEnforcementChecks the requested server against the connector broker registry and exits 2 if it is unregistered. In Book 3’s Chapter 1 incident (a composite), this is the line that would have stopped the unregistered server
5PostToolUse (all)HTTPEvidenceTool name, input and result (truncated to the first 4 KB) for every successful call. Joins gateway logs on session ID and time. This is evidence, not enforcement, because the call has already run
6ConfigChange (all)commandTamper detectionBlocks when the source of a settings or skills change is not policy_settings, and raises a high-severity SOC alert. It answers the auditor’s question of who changed the agent’s own policy mid-session
7PreCompact (all)commandEvidence preservationShips the full transcript before compaction summarises earlier turns away. Per Book 3 this is the only documented point at which the pre-compaction transcript can be guaranteed. It is the hook teams most often miss

Optional: if auto mode is enabled, add PermissionDenied, which Book 3 gives as the documented logging point for classifier denials [FACT-CHECK: whether a permissions.deny match also emits a hook event]. SessionStart can record which context files loaded (see CLAUDE.md below).

Configuration shape (field names per Book 3 Ch 8 PR-3 and App B §6.1; illustrative).

{
  "hooks": {
    "UserPromptSubmit": [{ "matcher": "", "hooks": [{ "type": "http",
        "url": "https://siem-ingest.example.internal/claude/prompts",
        "headers": { "Authorization": "Bearer $SIEM_TOKEN" },
        "allowedEnvVars": ["SIEM_TOKEN"] }] }],
    "PreToolUse": [
      { "matcher": "Bash",     "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/bash_guard" }] },
      { "matcher": "Edit",     "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/sensitive_file_guard" }] },
      { "matcher": "mcp__.*",  "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/mcp_registry_check" }] }
    ],
    "PostToolUse":  [{ "matcher": "", "hooks": [{ "type": "http", "url": "https://siem-ingest.example.internal/claude/tool_calls",
        "headers": { "Authorization": "Bearer $SIEM_TOKEN" }, "allowedEnvVars": ["SIEM_TOKEN"] }] }],
    "ConfigChange": [{ "matcher": "", "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/config_change_guard" }] }],
    "PreCompact":   [{ "matcher": "", "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/transcript_ship" }] }]
  }
}

Two warnings about hooks themselves.

  • Per WP3 §5.4, hooks and MCP servers run outside the sandbox. A hook script is unconstrained code on the host, so review it as you would privileged code.
  • Hooks run as the user, and so do their HTTP posts. Treat what they emit as a signal to corroborate against host process telemetry, not as tamper-proof evidence.

Source difference — HTTP hooks versus OTel. Book 3 builds the evidence stream from HTTP hooks to Microsoft Sentinel, and its Appendix B disables vendor telemetry (“out-of-band telemetry beyond the gateway path”). WP3 does not use hooks for evidence. It switches on Claude Code’s OpenTelemetry export by policy, and notes that the hooks’ evidence role was outside its scope. These do not conflict: CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC switches off Anthropic’s operational telemetry, while OTel export goes to the firm’s own backend. This page uses both layers: OTel for fleet-wide signals and source-drift detection, and command hooks for enforcement and its evidence. Whether App B’s DISABLE_TELEMETRY also suppresses OTel export is unverified [FACT-CHECK].

Step 6 — Sandbox: what it contains, and the Windows decision

Coverage and limits (per WP3 §5.4, 10 Nov 2026)

The sandbox applies operating-system limits on files and network to shell commands and their children. macOS uses the built-in Seatbelt. Linux and WSL2 use bubblewrap, which needs the bubblewrap and socat packages. Native Windows and WSL1 have no sandbox. By default sandboxed commands can write only to the working and temporary directories. Network traffic goes through a proxy that checks each host against an allow-list, which starts empty.

LimitConsequenceCompensating control
Covers shell commands only. File tools, MCP servers and hooks run outside itProtection for file tools comes from permission rules; MCP and hook code is unconstrainedSet both permission rules and sandbox. Run high-risk MCP work in a dev container or VM
Default read access covers most of the machine, including ~/.sshCredentials readable by sandboxed commandsRead denies (carried into the sandbox); Book 3’s sandbox.filesystem.denyRead, allowManagedReadPathsOnly and sandbox.credentials (v2.1.187+ per Book 3; no built-in list, only what you add) [FACT-CHECK]
Silent fallback to unsandboxed if the sandbox cannot start (Book 3 Ch 8 §6.2)A broken image runs unprotectedfailIfUnavailable: true
Claude may ask to retry a blocked command outside the sandboxThe Ona escape routeallowUnsandboxedCommands: false
Proxy does not terminate or inspect TLS. Broad domains such as github.com create exfiltration paths, and domain fronting may reach hosts outside the listHostname allow-listing is evadableA tight list with every entry justified and reviewed quarterly; TLS-inspecting proxy at the boundary for high-trust flows. Book 3 calls the in-sandbox tlsTerminate experimental as of August 2026 and not a basis for a control narrative [FACT-CHECK]
Inside a container the sandbox needs enableWeakerNestedSandbox, which considerably weakens itNested sandbox is not a boundaryRely on the container’s own isolation and network policy
excludedCommands has no managed-only lock; developers can always append (Book 3 Ch 8 §6.2)Commands can be taken out of the sandboxKeep the managed list narrow; detect excluded-command use from the PostToolUse stream [FACT-CHECK]
Unix sockets (e.g. /var/run/docker.sock) give effective host accessPrivilege escalationallowUnixSockets: false (App B); exceptions per project and per socket through change advisory [FACT-CHECK: key name and default]
The environment, including any secrets in it, passes to sandboxed commandsSecrets in env are readableKeep secrets out of the agent’s environment (Step 8)

The vendor summary, as WP3 quotes it, is that sandboxing reduces risk but is not a complete isolation boundary. It needs both halves: without network isolation files can be exfiltrated, and without filesystem isolation a network path can be opened. Where a whole-process boundary is required, use a per-repository dev container with only that repository mounted, a firewall on its network and no host credentials. Book 3 classes Anthropic’s @anthropic-ai/sandbox-runtime wrapper as a beta research preview, and not a control to anchor a compliance claim on (Aug 2026) [FACT-CHECK].

Platform prerequisites

PlatformRequirementVerify with
macOSSeatbelt is built in/status
Linux, WSL2bubblewrap and socat in the image. Ubuntu 24.04+ needs an AppArmor profile for bubblewrap’s user namespaces, without which sessions fall back to unsandboxed (Book 3 App B §3.3, Ch 8 §6.1). The optional seccomp filter for Unix-socket routes installs separately [FACT-CHECK]bwrap --version; aa-status | grep claude; /status shows sandbox enabled
WSL1Not supported; needs kernel namespacesIntune WSL settings disable WSL1
Native WindowsNot supported; commands run unsandboxed—

Native Windows or WSL2

Per WP3 §6.5, Anthropic’s own table marks sandboxing “Not supported” on native Windows and “Supported” on WSL 2. Telemetry from WSL carries wsl.version and os.type, so the split is visible without extra tagging.

StanceSourceMechanismAccept when
WSL2 by default; native Windows allowed under a stricter variantWP3 §6.5Omit failIfUnavailable from the native-Windows document. File-reach key, locks, endpoint application control and EDR carry more weight. Expect locked rules to be felt (no sandbox auto-allow)Windows-native development (for example .NET desktop) in lower tiers
WSL2 (or container/VM) onlyBook 3 Ch 8 §6.1, App B §3.2Intune compliance blocks Claude Code on hosts without WSL2 attestation. Inference, to be tested: with failIfUnavailable: true in the single HKLM document that WSL inherits, a native Windows session refuses to start while WSL2 sessions run sandboxedRegulated tiers; the firm cannot accept permission prompts as the only enforcement layer

Recommendation. Use WSL2 for all agentic work in regulated tiers. Allow native Windows only for named lower-tier populations, as a recorded exception. One friction, per Book 3: sandboxed commands in WSL2 cannot call Windows binaries under /mnt/c/, and the workaround (excludedCommands) runs them outside the sandbox. Keep Windows-native tooling as a separate surface rather than carving exceptions into the Claude Code one. Book 3’s composite Bank A granted one of three WSL2 exceptions, carving a legacy tooling group out of Claude Code entirely until migration.

In WSL, blockReadsOutsideWorkingDirectories stops the file tools reading Windows files under /mnt/c. Where an explicit rule is wanted, use Read(//mnt/c/**).

Windows endpoint posture and the processWrapper gap

  • No local administrator rights for developers. An administrator can edit the managed policy (WP3 §6.2).
  • EDR, application control over what spawned processes may run, and credential protection form the outer wall. The user-profile installer needs no admin rights, so application control is the only way to stop unaided installs. The binary is signed by “Anthropic, PBC”, which gives a publisher to write rules against. WP3 did not test such a rule. The HKLM policy applies to whatever the user installs.
  • Do not enable WebDAV or let Claude Code reach paths that may contain WebDAV subdirectories. The vendor warns that this can trigger network requests that bypass the permission system. Claude Code prompts before commands naming UNC paths.
  • Per Book 3 Ch 12 §4.9 (Aug 2026), processWrapper forces every process Claude Code launches through a corporate launcher on macOS, Linux and WSL, and refuses to start rather than run unwrapped. On Windows it is ignored, because the mechanism depends on exec. The architecture is processWrapper where it works, and AppLocker/WDAC plus HKLM managed settings on native Windows. Record the Windows residual as an accepted risk signed by the CISO, not as coverage [FACT-CHECK: processWrapper key and platform support].

Multi-session virtual desktops (WP3 §6.3)

Prefer personal host pools or cloud desktops for agentic work. Where multi-session hosts are used:

  • keep profiles separate and give each user a separate working directory;
  • apply the strictest tier;
  • treat ~/.claude as confidential;
  • remember that Windows credentials sit in a profile file protected only by profile ACLs;
  • remember that a loopback telemetry receiver is shared by every user on the host (Step 7).

Bake the client version, policy and telemetry agent into the image, so that a rebuilt host is compliant at first boot. A dedicated cloud desktop is a sound default for contractors: it applies firm policy and the firm’s network path, and keeps code off unmanaged hardware.

Step 7 — Network, proxy and mutual TLS

Egress allow-list. Per WP3 §9.1, the essential hosts for the Anthropic route are:

  • api.anthropic.com for model requests;
  • claude.ai, claude.com and platform.claude.com for sign-in;
  • sso.claude.com where SSO is used;
  • downloads.claude.ai for the installer and updates.

Book 3 Ch 6 §4.3 lists the full published table as of August 2026, including mcp-proxy.anthropic.com, storage.googleapis.com, bridge.claudeusercontent.com, raw.githubusercontent.com, code.claude.com and two Datadog intake hosts [FACT-CHECK: current list on the network-configuration page]. Enforce the list at the cloud firewall for desktops and build agents, and at the secure web gateway for laptops.

Residual Anthropic egress on third-party routes. On a Bedrock, Google or Foundry route, model traffic goes to the provider. However, WebFetch still sends the hostname to api.anthropic.com for a safety check unless skipWebFetchPreflight is set. Per Book 3 Ch 10 §5.3, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC does not stop that check. Update traffic to downloads.claude.ai also continues unless updates are pinned and disabled (Book 3 Ch 6 §4.3). Book 3’s closed-perimeter profile (Ch 6 §4.3; repeated in Ch 12’s landing-zone checklist) is:

  • CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1;
  • skipWebFetchPreflight: true, compensated by explicit WebFetch permission rules, or WebFetch denied as in the WP3 baseline;
  • DISABLE_UPDATES, which obliges the firm to run an internal binary channel, since security fixes then arrive only when the pin moves.

Name these flows in the data-flow inventory either way.

Proxy mechanics (per Book 3 Ch 6 §4.3 and WP3 §9.1).

  • HTTPS_PROXY, HTTP_PROXY and NO_PROXY are honoured, can be set in the managed env block, and are read once at startup.
  • SOCKS is not supported.
  • Proxy authentication beyond Basic is out of scope. For an NTLM- or Kerberos-only estate, Book 3 gives the documented remedy as an LLM gateway in the path.
  • The client trusts the OS certificate store. A TLS-inspecting proxy (Book 3 names Zscaler and CrowdStrike Falcon) works once its root is installed there.
  • For mutual TLS to the gateway, CLAUDE_CODE_CLIENT_CERT and CLAUDE_CODE_CLIENT_KEY carry the client certificate. Book 3 says they are re-read on settings change, so rotation is a file replacement, and that CLAUDE_CODE_CERT_STORE selects the CA store [FACT-CHECK: variable names and re-read behaviour].
  • Per Book 3 Ch 12, in app-managed sessions these variables are read only from managed settings and the user’s own file, so a checked-out repository cannot redirect the TLS path.

Tenant Restrictions. A TLS-inspecting proxy injects an anthropic-allowed-org-ids header on requests to Anthropic’s domains. Anthropic then blocks organisations not on the list (Enterprise plans and Console organisations; API-key and OAuth authentication). Per WP3 §9.1, the help article does not name Claude Code, although the Claude Code documentation points to it. Test it before relying on it.

Route binding through the managed env block. Per Book 3 Ch 8 §7, the managed env block replaces inherited shell values at start-up, and setting a variable to "" force-unsets a shell export. That makes it the enforcement point for ANTHROPIC_BASE_URL (gateway route) or CLAUDE_CODE_USE_BEDROCK/CLAUDE_CODE_USE_VERTEX plus region (cloud routes). A route deviation then shows up as a deployment failure, not as an engineer’s choice.

Open compatibility question. Book 3 App B combines forceLoginMethod: "claudeai" with an ANTHROPIC_BASE_URL pointing at the bank’s APIM. WP3’s baseline uses the Enterprise route with no base URL, and notes that a non-default base URL turns off the server-managed fetch. Whether claude.ai sign-in sessions can be routed through a customer gateway in this way, and what value allowedProviders then takes, is unverified [FACT-CHECK]. Book 3 Ch 8 PR-2 also uses "oauth" as the forceLoginMethod value where App B and WP3 use "claudeai". This page follows WP3.

Step 8 — Data on and from the workstation

What leaves the machine (WP3 §9.2)

The prompt and its context leave the machine: code, file contents and command output. Under commercial terms, Anthropic does not train on Claude Code prompts or code. Standard retention for Team, Enterprise and API is 30 days. Zero data retention is available for Claude Code only to qualified Enterprise accounts, enabled per organisation. It disables features that need server-side storage, and on cloud-provider routes the provider’s retention applies. Per Book 3 Ch 10, ZDR follows the authenticated organisation, not the device, so the login pin is also the ZDR precondition. Endpoint DLP does not see inside the TLS session to the model endpoint, so do not count on it for this channel. Use a gateway route if inline inspection is required. Decide which data classes and repository tiers may be worked on with Claude Code at all, and on which route.

Secrets

Services use workload identity against the secret store, pipelines use store-linked variables, and developers use short-lived tokens. The sandbox passes Claude Code’s environment, including any secrets in it, to the commands it runs. Any user on a machine can read managed-mcp.json, so it must hold no credentials. Scan agent-written changes before merge, because an agent shown a credential may repeat it (WP3 §9.3). See identity and secrets.

The workstation is a processing location

ZDR is a server-side property and does nothing to the laptop. Per WP3 §9.4 and Book 3 Ch 10 §5.3:

  • Transcripts are stored in plaintext under ~/.claude/projects/ for 30 days by default, to support session resumption. Book 3 found no supported way to disable local persistence entirely [FACT-CHECK].
  • On Windows and Linux, credentials are protected by file permissions only. The same endpoint holds the transcripts and the token.
  • The feedback commands (/feedback, /bug, /share) send conversation history, including code, to Anthropic with five-year retention (per Book 3) [FACT-CHECK].

A board pack can therefore say “zero data retention” while thousands of laptops hold weeks of cleartext source excerpts. Each statement is true on its own, and together they mislead.

Endpoint and retention baseline (Book 3 Ch 10 PR-2, with WP3 values):

#ControlSetting or actionOwner
1Pin sessions to the covered organisationforceLoginMethod, forceLoginOrgUUIDIdentity engineering
2Shorten local transcript retentioncleanupPeriodDays (WP3: 14; Book 3’s Bank A: 7)Security engineering
3Bring transcripts into endpoint scopeClassify ~/.claude/ as confidential; endpoint DLP rule; full-disk encryption check; exclude from backup and sync paths into lower-trust storageEndpoint security
4Block feedback exfiltrationDISABLE_FEEDBACK_COMMAND=1 in managed env (needed where ZDR is not enabled; ZDR disables the commands at the backend, per Book 3)Security engineering
5Disable non-essential trafficCLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1Security engineering
6Decide the WebFetch preflightAllow api.anthropic.com at the proxy, or skipWebFetchPreflight plus WebFetch rulesNetwork + security
7Name the workstation in the GDPR Article 30 record of processingUpdate the recordDPO
8Record ZDR carve-outsDPIA and records scheduleDPO
9Store ZDR enablement evidence per organisationThird-party register fileRisk / vendor management
10Agree the position on prompt content in the SIEMWorks-council agreement and DPIA before the stream goes live; prompt content in a SIEM is employee monitoringDPO + HR + SOC

Presence-based flags (Book 3 Ch 8 §7). The DISABLE_* variables act on presence. DISABLE_TELEMETRY=0 disables telemetry. A compliance script that sets “0” to mean “on” will be wrong [FACT-CHECK]. Verify the merged env block with /status, and confirm the result with the retention_sweep telemetry event (WP3 §9.4), which shows whether machines apply the managed retention period. Legal treatment of these records is on the regulatory map.

Step 9 — Telemetry, detections and the evidence pack

Configure the export (per WP3 §10, 10 Nov 2026)

Claude Code exports OpenTelemetry metrics and events (as OTel logs); traces are in beta. Export is off until configured, so monitoring is a policy decision. Two properties make the managed configuration trustworthy:

  • From 2.1.282, OTel exporter variables in a repository’s settings files are ignored, so a repository cannot turn telemetry on, redirect it or capture content.
  • When an OTLP variable is set in managed settings, conflicting developer-set variables are removed at startup.
TransportUse whereCaution
Local agent receiver on 127.0.0.1:4317Single-user hosts, build agentsBind the receiver to loopback. Datadog’s Claude example shows 0.0.0.0; Datadog’s own OTLP page says 0.0.0.0 is used for convenience. OTLP log ingestion is off by default (Agent 7.48.0+)
Direct to intakeHosts without an agentNeeds a distributed API key
Central collectorMulti-session hosts; anywhere credentials should stay server-sideLoopback is per host, not per user, and an unauthenticated receiver lets any user forge another’s telemetry

What arrives.

  • Metrics (claude_code. prefix): session.count, active_time.total, cost.usage, token.usage, lines_of_code.count, commit.count, pull_request.count, code_edit_tool.decision.
  • Events: user_prompt, api_request, api_error, tool_result and tool_decision, linked by prompt.id.
  • Security-relevant events: permission_mode_changed, auth, mcp_server_connection, safety_event (2.1.307+), managed_settings_resolved (2.1.274+) and retention_sweep.
  • tool_decision carries decision of accept or reject and a source such as config, hook or user_reject. A filter on decision=deny matches nothing.
  • service.name is claude-code for the terminal and claude-code-desktop for the desktop app. Filters need both.

Identity depends on the route. user.email, user.account_uuid and organization.id appear only on Claude-account sessions. On API-key, Bedrock, Google or Foundry routes only user.id (a random installation ID) and session.id are populated. Attach identity there with OTEL_RESOURCE_ATTRIBUTES set by a launch wrapper.

Content is off by default. Content is controlled by OTEL_LOG_USER_PROMPTS, OTEL_LOG_ASSISTANT_RESPONSES, OTEL_LOG_TOOL_DETAILS and OTEL_LOG_TOOL_CONTENT. Leave prompt and response content off and record that choice. Enable OTEL_LOG_TOOL_DETAILS (command strings, MCP server and tool names) only into a store approved for source-level content.

Detection rules

These are WP3 §10.3 monitors (OTel) and Book 3 Ch 8 PR-4 rules (hooks to SIEM). All are design proposals.

DetectionSignalSeverity / routingThreatSource
Telemetry gap (build first)Host agent sees a claude process; no claude-code telemetry from that hostHighT8: policy removed, export blocked, client replacedWP3
Policy source driftmanaged_settings_resolved with managed_settings.sources not the expected sourceHighDevice policy displaced (Step 2)WP3
ConfigChange from non-policy sourceConfigChange event with source ≠ policy_settingsHigh; Tier 2 immediatelyT8Book 3
Mode escalationpermission_mode_changed to bypassPermissions outside the CI allow-listHighT3, T8WP3
Unauthorised MCP attemptPreToolUse deny on mcp__.*Tier 2T5Book 3
Sensitive-file attemptPreToolUse deny on the sensitive-file guardSOC, with engineer identity and projectT4Book 3
Bash blocklist hitPreToolUse deny on BashSelf-service triage; Tier 2 on a second hit by the same engineer within 24 hT1, T3Book 3
Sandbox unavailable / excluded commandSession reports sandbox unavailable, or PostToolUse shows a command in excludedCommandsTier 2Runtime gapBook 3
Rejection spiketool_decision decision=reject, or safety_event category managed_policy/permission_rule, above a per-user baselineMediumT1 or probingWP3
Unknown organisationorganization.id not the firm’s, or user.email outside the domain (subscription route only)HighT6WP3
CI privilege drifttool_result from an edit or shell tool in a read-only pipeline profileHighT7WP3
Cost anomaly / API error surgeclaude_code.cost.usage per team or pipeline; api_error rateMediumRunaway loops; misconfigurationWP3

The telemetry-gap monitor is the one that still works after everything else has been switched off, because it compares what the tool reports with what the host reports. The client emitting telemetry runs as the user, so the user can always fabricate it. Host process telemetry (EDR, or the kernel audit subsystem on Linux) is the independent record, and it wins when the two disagree. The vendor emits the raw event stream only; baselining, correlation and alerting are the backend’s job. Write sequence detections as well, for example many file reads followed by a rejected network attempt.

False positives are fixed by policy, not by tickets (Book 3 Ch 8 PR-4). Triage to a 24-hour objective for the first cohort and 48 hours at general availability. Every false positive lands as a policy change in the next tier document or fragment, through change advisory. Never grant a per-engineer exception. Book 3 reports that its composite cohort’s false positives fell to near zero by week three on that rule. In the same composite, a curl to the internal artefact repository from a three-year-old build script took 18 hours to resolve and was formalised in the cohort fragment.

Evidence pack (WP3 §11; Book 3 App B §8)

EvidenceProvesRetain
Version history of the managed policy and hook bundle, with change recordsControl design and change control (policy change is a control change)Firm’s evidence horizon
Device-management compliance reports (policy present, version floor, WSL2 attestation)DeploymentPer cohort gate and annually
managed_settings_resolved events, monitor history, detection outcomesOperating effectivenessAs above
Compliance API / audit-log export (Enterprise only; not available for Foundry per WP3), including changes to server-managed settingsAdministrative recordAs above
Synthetic-test results per cohort gate (below)Controls fire end to endPer gate

Route events into the audit evidence spine. Claude-related incidents follow incident response.

Step 10 — The regulated CI invocation profile

The interactive profile cannot run on build agents, because the login keys block workload credentials. Non-interactive use is also where the agent becomes an unattended actor holding pipeline privileges (T7).

Documented behaviours that set the profile (per WP3 §8).

  • claude -p runs a project’s .claude/settings.json hooks and connects its .mcp.json servers, even in an untrusted folder, without a trust dialog. A pull request that adds a hook is asking the pipeline to run a command.
  • --allowedTools pre-approves; it does not restrict. Use --tools to restrict built-in tools. --tools does not affect MCP tools, so add --disallowedTools "mcp__*".
  • From 2.1.302, runs with no mode start in Manual mode, where calls that need approval are denied. dontAsk makes the denial explicit.

Profile.

  1. Where it runs. Use self-hosted scale-set agents built from a custom image with the pinned client and the CI policy, torn down after each job, with egress restricted on the subnet. Container jobs on those agents are stronger (from agent 5.279.0 the host Docker socket is not mounted by default). Network restriction comes from the subnet, not the container. Avoid Microsoft-hosted agents for this, because everything would then come from the pipeline definition, which a pull request can change.

  2. Policy in the image, not the repository. Bake a CI managed-settings.json into the image that sets:

    • allowManagedPermissionRulesOnly, so --allowedTools and repository rules are ignored;
    • allowManagedHooksOnly, so repository hooks do not run;
    • an empty managed-mcp.json, so repository MCP servers do not load;
    • allowedProviders set to the pipeline’s provider;
    • and it omits the two login keys.

    Require reviewer approval for changes to pipeline definitions and .claude/.

  3. Split the pipeline. No deployment-capable credential in any job that runs an agentic step on untrusted input. The unprivileged agentic stage produces artefacts. A non-agentic stage behind a human or deterministic gate consumes them, and treats them as attacker-influenced text. See release engineering.

  4. Credentials. Use workload identity (Foundry with Entra ID, where there is no key to store), or a secret-store-linked variable group.

  5. Invocation. Use claude -p with --tools (a read-only set such as Read,Grep,Glob for review), --disallowedTools "mcp__*", --permission-mode dontAsk and --output-format json.

  6. Evidence and fail-fast (per Book 3 Ch 9 §5.3, Aug 2026). Archive session_id and total_cost_usd from the JSON output for every run. Hard-fail the pipeline if the system/init event has a non-empty mcp_server_errors or plugin_errors array, because otherwise a control is silently absent. Book 3 also recommends --bare (no auto-discovery of hooks, plugins, MCP servers or memory files, and no keychain OAuth) [FACT-CHECK: whether --bare also skips managed hooks; if it does, it conflicts with a managed evidence hook in the image].

  7. Telemetry mandatory, with pipeline and project resource attributes.

  8. No bypass mode. dontAsk with managed allow rules gives a fixed envelope. Mandatory checks go in PreToolUse hooks, never in an SDK canUseTool callback, because auto-approved tools never reach the callback (Book 3 Ch 9).

  9. Human review for effects. Code changes arrive as a pull request and branch policy enforces review.

Source difference. Book 3 Ch 9’s reference invocation scopes the run with --allowedTools and dontAsk. WP3’s image policy sets allowManagedPermissionRulesOnly, which makes --allowedTools ignored. Under WP3’s design, the allowed set belongs in the image’s managed rules and restriction comes from --tools. This page follows WP3. Use Book 3’s evidence and fail-fast items on top.

IDE extensions and CLAUDE.md

IDE extensions (Book 3 App B §7, May 2026). The VS Code and JetBrains extensions read the same managed settings and run the same hook bundle as the CLI. PreToolUse and ConfigChange block IDE-initiated actions on the same code path. The firm controls the install path, not the extension binary.

  • VS Code: publish the extension through Intune or an internal gallery, version-pinned to the CLI release. Block public-marketplace installs with VS Code enterprise policy: extensions.allowed, extensions.autoUpdate: false and extensions.gallery.serviceUrl pointing at the internal gallery.
  • JetBrains: publish through an internal plugin repository and set idea.plugins.host. Block the public marketplace with idea.plugins.allow-from-repo-only=true.

[FACT-CHECK: all VS Code and JetBrains policy names, and inheritance of managed settings by the extensions, as of Nov 2026.]

Acceptance check: /status, /permissions and /mcp run from the IDE panel must match the CLI output. Any divergence is a deployment defect.

CLAUDE.md as labelled guidance (Book 3 Ch 8 PR-5). Every in-scope repository carries a root CLAUDE.md, explicitly marked guidance, not control. A pre-commit hook validates its mandatory sections:

  • project identity (repository, owning team, contact, sensitivity class);
  • team-specific approved Bash patterns above the floor (usually none) and sensitive-file patterns that feed the managed hook;
  • MCP servers in scope, with broker IDs;
  • risk tier and critical-or-important-function (CIF) flag, which decide the tier document and whether disableWorkflows applies;
  • review cadence: quarterly for higher tiers, six-monthly for the lowest, with a named reviewer.

A SessionStart hook records which context files loaded. That makes the guidance auditable even though it is not enforceable. A weekly governance scan flags absent or stale files. Anything that must bind goes in managed settings or a hook.

Rollout: cohorts, gates and exceptions

Phases (WP3 §12.2; proposal and estimated durations).

PhaseWeeksContentExit criteria
0 Decide1–2Per use case, the route; then hosting option, repository tiers, a single managed source, the auto-mode position, the acceptable-use policy and the register entryBaseline and tier map signed off
1 Pilot3–6About 10 developers on Windows with WSL2, plus one Linux pipeline; registry policy with WSL inheritance; telemetry pathTelemetry from every pilot session; /status shows the expected source on every machine
2 Harden6–10Tune rules from real use; sandbox on without unsandboxed retry; telemetry-gap, mode-escalation and source-drift monitors; CI image profileTwo weeks without monitor noise; a tamper test is caught
3 Scale10–16Rings across teams, virtual desktops and Linux; contractor pattern; team budgetsEvery surface covered; evidence pack produced
4 OperateOngoingQuarterly policy review against the documentation; version floor raised; MCP allow-list board; injection exercisesRecurring review records

Book 3’s composite Bank A ran faster (Ch 8 §8):

  • cohort 1 was 40 senior engineers from the team accountable for the previous incident, with the full package in week 1 and the first fixes by week 3;
  • cohort 2 was 60 platform engineers, then roughly doubling: 400 engineers by week 8, 900 by week 12 and the full 12,000-seat estate by week 24.

Book 3 Ch 8 PR-1 adds a cadence for general availability: weekly hook-volume review for the first quarter, quarterly after that.

Use the pilot’s rejection and prompt counts to set strictness from data. Too strict, and developers route around the tool. Too loose, and the policy is decoration.

Version cadence (WP3 §6.1).

  • Package a pinned version. WinGet Anthropic.ClaudeCode does not self-update.
  • Use autoUpdatesChannel: "stable", which runs about a week behind latest, or DISABLE_AUTOUPDATER / DISABLE_UPDATES with an internal ring.
  • Bound what may start with requiredMinimumVersion and requiredMaximumVersion.
  • Several controls on this page exist only above a specific build, so the version floor is itself a control.

Cohort-gate verification (Book 3 App B §8; run at commissioning, at every gate and annually as an IT general control).

#TestPass condition
1/statusManaged settings loaded from the expected source (WP3 Setting sources line); version at or above the floor; route matches the cohort
2/permissionsOnly managed rules; bypass disabled; no rule sourced from user or project scope
3/mcpVisible servers equal the allow-list minus denies
4Synthetic Bash block (e.g. a harmless rm -rf on a scratch path)Exit 2 from the Bash guard; SIEM record at high severity within 60 seconds
5Synthetic sensitive read (.env)Read deny fires; SIEM or OTel record arrives
6Synthetic MCP call to an unregistered serverRegistry check exits 2; record arrives
7Synthetic promptUserPromptSubmit record carries session, working directory, host metadata, redacted body
8Tamper: add an allow to ~/.claude/settings.jsonConfigChange blocks; high-severity record with source ≠ policy_settings
9Device compliance100% of the cohort on the baseline; WSL2 attestation compliant on every Windows device
10Sandbox/status shows enabled and fail-if-unavailable; bwrap --version; AppArmor profile loaded on Ubuntu 24.04+
11Source drift (added by this page from WP3 §5.1; not in App B)Saving a test key in a non-production console organisation is visible in managed_settings_resolved

Exceptions. Route every exception and baseline change through the change process (Book 3’s Virtual CAB). Each needs a named owner, a stated cohort scope and an expiry date. Book 3 warns that a managed-settings diff which grows monotonically, with no compensating denies, is drift that nobody can defend in audit.

Ownership

WP3 §11 names four owners (security engineering, platform, application security, risk). This page adds identity engineering, the SOC, the DPO, internal audit and the developer from the Book 3 chapters cited above.

RoleOwns
Security engineeringPolicy baseline and tier documents; hook logic; detections content; quarterly re-check against the documentation
Platform engineeringPackaging, version rings, delivery channels (Intune, configuration management, images), telemetry plumbing, developer experience
Identity engineeringOrganisation pinning, SSO/SCIM, workload federation, credential precedence
Application securityRepository tiering, review gates, the CLAUDE.md standard, the CI split
SOCDetection response, false-positive triage SLOs, telemetry-gap follow-up
Data protection officerArticle 30 entry for the workstation, DPIA, the position on prompt content in telemetry
Risk and vendor managementICT third-party register entry per route; materiality; the record of accepted residual risks (native Windows, processWrapper), which the CISO signs per Book 3 Ch 12
Internal auditAnnual cohort-gate re-run as an IT general control; evidence pack review
Developer or pipeline ownerAccountable for what is committed and deployed. Agent output passes the same review and branch protection as human code, and the agent never becomes an unreviewed committer (WP3 §11)

Per WP3 §11, Claude Code should pass through existing frameworks as an ICT third-party service and an internal tool. That means a register entry per route (Anthropic as provider on every route, including Foundry), an AI inventory entry with an accountable owner, and a processing agreement and records of processing per route. Article-level mapping is on the regulatory map and the control map.

Failure modes and recovery

FailureHow to recognise itRecovery
Baseline shipped without lock flags/permissions shows rules sourced from user files; developer-added MCP servers visible in /mcpSet all allowManaged*Only flags and the sideload locks; re-sample weekly for a quarter
Device policy silently displaced by a console keySource-drift monitor; /status names the server sourceClear the console, or adopt managedSourcesBehavior: "merge" deliberately
WSL running under a user-writable fileWSL /status names /etc/claude-code; no wslInheritsWindowsSettingsSet inheritance in HKLM; remove reliance on the in-distribution file
Invalid JSON in a managed fileClaude Code fails to start fleet-wide after a releaseSchema-validate in the pipeline; roll back the document; WP3 notes the published schema can lag the CLI
Enforcement wired as an HTTP hookA gateway timeout lets through the action the hook was written to denyConvert every blocking decision to a command hook
Hooks emit, nobody watchesSIEM ingests Claude events with no analytics rules referencing themOne detection per hook event; review volumes weekly at first
Sandbox silently absentSandbox-unavailable detection; /status; Ubuntu 24.04 without the AppArmor profilefailIfUnavailable: true; fix the image
Native-Windows sidestepClaude process with no WSL2 attestation; os.type and wsl.version in telemetryBlock at device compliance, or record as an exception with expiry
availableModels without enforceAvailableModelsUsage registry shows an unapproved model resolved via “Default”Add the flag; pin full IDs; reconcile on model governance
Telemetry receiver on 0.0.0.0 or shared loopbackTelemetry from unexpected senders; multi-session hostsBind to loopback; central authenticating collector on shared hosts
Guidance counted as controlRCSA cites CLAUDE.md or skills as preventiveRe-sort into the two columns; move what can move into settings or hooks
Permissions drift across cohortsManaged diff only ever growsChange process with owner, scope and expiry per exception
Pipeline runs repository hooks or MCPsystem/init lists unexpected servers; repository .claude/ changed in a pull requestCI policy in the image; empty managed-mcp.json; reviewer gate on .claude/

Acceptance checks

  • One managed source per surface; /status confirms it on Windows, WSL2, Linux, macOS and CI; console managed settings empty or deliberately merged.
  • Windows policy at HKLM\SOFTWARE\Policies\ClaudeCode; WSL inherits it; WSL1 disabled.
  • Login method, organisation and provider pinned by device policy; no API keys on endpoints.
  • Bypass mode disabled; permission rules, hooks and MCP servers locked to the managed set; sideload flags closed.
  • Permission rules meet the authoring standard: no argument-constraining allows, no environment runners, no Write/Glob path rules.
  • availableModels with enforceAvailableModels and full model IDs.
  • Auto mode, workflows and sandbox mode positions recorded per tier.
  • Every blocking hook is a command hook; the bundle includes ConfigChange and PreCompact; HTTP hook URLs bounded.
  • Sandbox on with failIfUnavailable and no unsandboxed retry on Linux, WSL2 and macOS; prerequisites verified; domain list justified entry by entry.
  • Native Windows either blocked or covered by a recorded, expiring exception with application control and the processWrapper residual accepted.
  • Telemetry on by policy; receiver on loopback or a central collector; content variables off unless approved.
  • Telemetry-gap, source-drift, mode-escalation, ConfigChange and cost detections active; a tamper test detected.
  • cleanupPeriodDays set; feedback commands blocked; workstation named in the Article 30 record; DPIA covers carve-outs and SIEM content.
  • CI policy in the image; agentic stage unprivileged; privileged stage gated; init-event errors fail the job.
  • Cohort-gate tests 1–11 pass and are filed in the evidence pack.

Source conflicts recorded on this page

TopicBook 3 saysWP3 / later source saysThis page follows
Windows registry pathApp B: HKLM\SOFTWARE\Anthropic\ClaudeCodeWP3 and Ch 8: HKLM\SOFTWARE\Policies\ClaudeCodeWP3 (App B error noted for manuscript correction)
Source combinationApp B: “registry takes precedence if both present”; Ch 8 flags dual delivery as unconfirmedWP3: first source delivering any key wins; others ignored silently; merge only by managedSourcesBehaviorWP3
WSL policyApp B: /etc/claude-code inside WSL2 governsWP3: user-writable on WSL; use wslInheritsWindowsSettingsWP3
MCP allow-list identityApp B: serverName entriesWP3, Ch 8 PR-2: name entries are not a security control; use serverUrl or commandWP3 (App B noted for correction)
Write path deny rulesApp B uses themCh 8: never consultedCh 8
Hook countApp B: sixCh 8: seven (adds PreCompact)Ch 8
Vendor telemetryApp B: disable; evidence through HTTP hooksWP3: OTel export by policy to the firm’s backendBoth, as layers
Native WindowsBook 3: WSL2 onlyWP3: WSL2 default, native allowed under stricter variantTier-dependent decision
forceLoginMethod valueCh 8 PR-2: "oauth"WP3, App B: "claudeai"WP3
Model listApp B: aliasesCh 8: full IDs + enforceAvailableModelsCh 8
disableAutoModeApp B: top-level, disabledWP3: placement inconsistent in docs; left outWP3 (decision per tier)
CI tool scopingCh 9: --allowedTools + dontAskWP3: --tools restricts; image lock ignores --allowedToolsWP3
Version floorApp B: v2.1.130+ (May 2026)WP3: 2.1.302 (Nov 2026)WP3

Provenance and refresh

The primary source is Research Paper 3, especially:

Hooks, lock flags beyond the base three, the authoring standard, IDE policy, rollout gates and the endpoint retention baseline come from Book 3 Chapters 5, 6, 8, 9, 10 and 12 and Appendix B. These are dated August and May 2026 and were not re-verified.

Re-check procedure (WP3 §13), at every Claude Code release that touches settings and at least quarterly:

  1. Open the Claude Code settings reference, the managed-settings page, the permissions, sandboxing, hooks and monitoring pages, and the changelog from the firm’s current floor forward. WP3’s references give the pages, for example code.claude.com/docs/en/managed-settings and code.claude.com/docs/en/settings-reference.
  2. Confirm each key in the base and overlay documents, its scope and its minimum version. Clear or keep each [FACT-CHECK] marker on this page.
  3. Run claude doctor and /status on one machine per surface and compare the Setting sources line with the intended source.
  4. Validate the policy documents against the published JSON schema, remembering that it can lag the CLI.
  5. Re-run cohort-gate tests 4–8 and 11.

Source material

  • Research Paper 3, Securing Claude Code in the Enterprise (version 1.0, November 2026; vendor facts verified against documentation on 10 November 2026) — §3 threat model and control philosophy; §4 identity and tenancy; §5 managed settings, baseline policy, MCP and hooks, sandboxing; §6 Windows estate; §7 Linux and WSL2; §8 CI/CD; §9 network and data; §10 monitoring; §11 governance mapping; §12 roadmap and checklist; §13 limitations
  • Book 3 (Deploying Claude Safely), Chapter 8, Claude Code at the Workstation (Draft 2, August 2026) — guidance versus control, lock flags, permission-rule authoring, auto mode and dynamic workflows, the seven required hooks, hook semantics, sandbox defaults, managed env block, cohort rollout, anti-patterns, PR-1 to PR-5
  • Book 3, Appendix B, Claude Code Enterprise Settings Baseline (Draft 1, May 2026) — settings hierarchy, per-OS deployment, reference managed-settings.json, lockdown field matrix, six-hook bundle, IDE extension policy, cohort-gate verification checklist
  • Book 3, Chapter 5, Identity and Access (§4.2 credential precedence; PR-3 configuration starting points)
  • Book 3, Chapter 6, The LLM Gateway and Policy Decision Point (§4.3 egress, proxy and mutual TLS; §5.2 the Claude apps gateway)
  • Book 3, Chapter 9, The Anthropic API and Agent SDK (§5.3 permission pipeline and regulated CI invocation; PR item 8)
  • Book 3, Chapter 10, Data Classification, Retention and DLP (§5.3 what stays on the endpoint; §9 anti-patterns; PR-2 endpoint and retention baseline)
  • Book 3, Chapter 12, The Landing Zone Tied Together (§4.9 processWrapper; §6.1 named exceptions)

← All AI Delivery Factory guidance

On this page

  1. How to read the vendor facts on this page
  2. The baseline in one table
  3. Why the settings file is not the boundary
    1. The vendor says so
    2. Threats the baseline is built against (WP3 §3.2)
    3. Guidance versus control: sort every policy line
  4. Step 1 — Choose the identity route and pin it
    1. Approved routes (per WP3 §4.1, 10 Nov 2026)
    2. Identity rules (per WP3 §4.2, 10 Nov 2026)
    3. Credential precedence is the bypass surface
    4. Where the Claude apps gateway fits
  5. Step 2 — Deliver one managed policy per surface
    1. Settings scopes and how permission rules combine
    2. Delivery mechanisms per OS (per WP3 §5.1, 10 Nov 2026)
    3. The sources do not merge: choose one
    4. Per surface
    5. Fail-closed settings fetch
  6. Step 3 — Ship the baseline policy
    1. The base document (per WP3 §5.2, 10 Nov 2026)
    2. Regulated-tier overlay (Book 3 additions, not re-verified by WP3)
    3. Lock flags and sideload closure
    4. Permission-rule authoring standard
    5. Model gating
  7. Step 4 — Decide the autonomy defaults before rollout
  8. Step 5 — Hooks: enforcement and evidence
    1. Operating semantics (per Book 3 Ch 8 §5.2 and App B §6.2)
    2. The required hook bundle
  9. Step 6 — Sandbox: what it contains, and the Windows decision
    1. Coverage and limits (per WP3 §5.4, 10 Nov 2026)
    2. Platform prerequisites
    3. Native Windows or WSL2
    4. Windows endpoint posture and the processWrapper gap
    5. Multi-session virtual desktops (WP3 §6.3)
  10. Step 7 — Network, proxy and mutual TLS
  11. Step 8 — Data on and from the workstation
    1. What leaves the machine (WP3 §9.2)
    2. Secrets
    3. The workstation is a processing location
  12. Step 9 — Telemetry, detections and the evidence pack
    1. Configure the export (per WP3 §10, 10 Nov 2026)
    2. Detection rules
    3. Evidence pack (WP3 §11; Book 3 App B §8)
  13. Step 10 — The regulated CI invocation profile
  14. IDE extensions and CLAUDE.md
  15. Rollout: cohorts, gates and exceptions
  16. Ownership
  17. Failure modes and recovery
  18. Acceptance checks
  19. Source conflicts recorded on this page
  20. Provenance and refresh

All pages in Build the platform →