deepworkplan-addon-devcontainer skill
Provides a reproducible, isolated development container for repositories using devcontainer-kit to manage environments and agent profiles.
- GitHub stars
- 24
- Files
- 3
- Last commit
- Oct 28, 2026
- License
- MIT
- Allowed tools
- 6
What does the deepworkplan-addon-devcontainer skill do?
deepworkplan-addon-devcontainer provides a reproducible, isolated development container for repositories using devcontainer-kit to manage environments and agent profiles.
Summary generated from the skill's SKILL.md.
About the deepworkplan-addon-devcontainer skill
Providing a reproducible and isolated development environment for repositories is what this addon enables for developers and AI agents. It acts as a thin integrator for devcontainer-kit, using the dck command to detect the kit and manage environments. When an agent loads this skill, it can render a repository's specific layout, including files like .devcontainer/devcontainer.json, docker/local/Dockerfile, and dev.sh, without requiring a shared base image.
Users can manage their environments through a terminal using bash dev.sh up or via VS Code and Cursor. The tool handles complex configurations such as SSH agent forwarding, Herdr machine registration, and optional mesh networking between containers. It is designed to reconcile existing repository layouts without overwriting them, ensuring that loopback ports and agent forwarding remain intact. Because it relies on official runtime images pinned by digest, it ensures that every developer and agent works within the exact same toolchain and service configuration.
What an agent can do with it
- 1Initialize a standardized dev containerA developer can use the addon to render a repository's specific Docker and compose files from an official runtime image.
- 2Run isolated development servicesAn AI agent can spin up a complete development environment including specific services and a pinned toolchain.
- 3Securely share host credentialsDevelopers can opt-in to allow containerized agents to use their existing host profiles and Claude tokens.
- 4Validate environment integrityUsers can check for configuration drift or kit compatibility using a diagnostic command.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the deepworkplan-addon-devcontainer skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the deepworkplan-addon-devcontainer skill in Claude Code
~/.claude/skills/deepworkplan-addon-devcontainer/SKILL.md
$ npx degit DailybotHQ/deepworkplan-skill/.agents/skills/deepworkplan/addons/devcontainer ~/.claude/skills/deepworkplan-addon-devcontainerInstall the deepworkplan-addon-devcontainer skill in Claude Code (project)
.claude/skills/deepworkplan-addon-devcontainer/SKILL.md
$ npx degit DailybotHQ/deepworkplan-skill/.agents/skills/deepworkplan/addons/devcontainer .claude/skills/deepworkplan-addon-devcontainerInstall the deepworkplan-addon-devcontainer skill in Codex
~/.agents/skills/deepworkplan-addon-devcontainer/SKILL.md
$ npx degit DailybotHQ/deepworkplan-skill/.agents/skills/deepworkplan/addons/devcontainer ~/.agents/skills/deepworkplan-addon-devcontainerInstall the deepworkplan-addon-devcontainer skill in Gemini CLI
~/.gemini/skills/deepworkplan-addon-devcontainer/SKILL.md
$ npx degit DailybotHQ/deepworkplan-skill/.agents/skills/deepworkplan/addons/devcontainer ~/.gemini/skills/deepworkplan-addon-devcontainerInstall the deepworkplan-addon-devcontainer skill in Claude.ai
npx degit DailybotHQ/deepworkplan-skill/.agents/skills/deepworkplan/addons/devcontainer deepworkplan-addon-devcontainer && zip -r deepworkplan-addon-devcontainer.zip deepworkplan-addon-devcontainer # claude.ai → Customize → Skills → + → Create skill → Upload a skill → deepworkplan-addon-devcontainer.zip
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A skill needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachabledailybothq/deepworkplan-skill/.agents/skills/deepworkplan/addons/devcontainer is public and reachablegithub.com/dailybothq/deepworkplan-skill/tree/HEAD/.agents/s ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-10-28github.com/dailybothq/deepworkplan-skill/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdTells the agent to read credentials on line 151github.com/dailybothq/deepworkplan-skill/blob/HEAD/.agents/s ↗Finding
- Pre-approved tools are scopedBash lets the agent run any shell command without askinggithub.com/dailybothq/deepworkplan-skill/blob/HEAD/.agents/s ↗Finding
- SKILL.md follows the Agent Skills formatthe description does not say when to use the skill; name "deepworkplan-addon-devcontainer" differs from the folder "devcontainer"github.com/dailybothq/deepworkplan-skill/blob/HEAD/.agents/s ↗Finding
SKILL.md
View on GitHubDeepWorkPlan — Devcontainer Addon
Give the repository a reproducible, isolated dev container that any human
or AI agent can open the same way — from a terminal (bash dev.sh up), from
VS Code / Cursor ("Reopen in Container"), or with the devcontainer CLI.
This is an opt-in addon, never required for a repo to be AI-first and
never a conformance gate.
This addon is a thin integrator of devcontainer-kit
(https://github.com/DailybotHQ/devcontainer-kit, MIT, works without DWP).
The Dockerfile template, the render (dck init), the pinned images and
tools, the entrypoint, SSH, Herdr registration and the dck-dockerfile
skill are the kit's; this addon decides whether to offer it, which
options fit the repository, and how to validate the result. It
carries no copy of the template and no company-specific network, volume or
file name.
| Pin | Value |
|---|---|
| Product | DailybotHQ/devcontainer-kit |
| Tag | v1.0.1 (per-repository Dockerfile, no shared base image; host accounts through [agents] host_profiles since v0.3.0; the antigravity kind, per-developer CLI choice ([agents] supported) and non-shared profiles on the agents volume since v0.3.6; coding-agents-kit v0.7.1 and herdr-peers v0.3.2 baked in since v0.3.7; the first stable release, its interface committed to semantic versioning, baking coding-agents-kit, herdr-peers and deepworkplan-vim v1.0.0, v1.0.0; coding-agents-kit v1.0.1 baked in, so @default stays the container's own account, and a dck doctor warning when a shared codex@default mixes host and container Codex versions, since v1.0.1) |
| Interface | 2 (dck doctor --json → "interface": 2) |
| Skill | dck-dockerfile, installed from the same tag |
| Registry key | devcontainer (.dwp/config.json → addons.devcontainer) |
| Abilities | none (it provides an environment, not a delegation transport) |
Read these first (all relative inside the skill)
SPEC.md— the normative contract.templates/INTEGRATION.md— reasoning aid: stack → runtime, ports and agents, the Herdr container profile, validation.
When this runs
onboard Phase 7b offers it when the repository benefits from an isolated,
reproducible environment (services, a pinned toolchain, agents that should
not touch the host); or on direct invocation. No other flow requires it.
What the kit renders (one layout, every repository)
.devcontainer/devcontainer.json # opens the same compose service as dev.sh
docker/local/<service>/Dockerfile # plus its entrypoint and layer scripts
docker/local/docker-compose.yaml
dev.sh # up, down, shell, exec, build, rebuild, herdr
The Dockerfile starts from the official runtime image (node, python or
debian) pinned by tag@sha256:digest. No shared base image is required:
the repository owns its Dockerfile, and nothing depends on the kit's GHCR
image. The kit's managed blocks carry a render stamp, so dck init
re-renders them and dck doctor reports drift; a project section outside
them survives every re-render. An existing dev.sh is kept.
The options live in .devcontainer/dck.toml (interface 2; dck init
migrates an interface-1 file). dev.sh is the one entry point
(bash dev.sh up builds, starts and registers). ssh_agent (default on)
gives git over SSH through the host's agent, so no private key enters the container
unless the developer turns on [ssh] copy_keys in their host profile (below).
[herdr] machine registers the container as a Herdr machine, and
[herdr] layout = "standard" opens it with the App · Editor · Development ·
Agents sidebar ("none" skips it). Every image carries herdr-peers.
[herdr] mesh (optional, default true, Docker Desktop only) lets agents
inside reach the other dck containers; it widens trust between containers,
so say so when you offer it, and mesh = false keeps the container on its
own. The agent socket follows the Docker provider: Docker Desktop and
OrbStack share the host agent, a native Linux engine mounts
$SSH_AUTH_SOCK, and other runtimes get none in exec sessions (dck ssh
and Herdr sessions still forward it). With ssh_host_config (default on),
git over SSH with your own ~/.ssh/config aliases (git@github.com-work:…)
works inside: dck up and dck rebuild copy the aliases for git hosting
services (GitHub, GitLab, Bitbucket, Azure DevOps, Codeberg, sourcehut) with
public keys and already-trusted host keys only — no private key is
copied — and only aliases whose key the host agent holds. On a terminal dck
offers ssh-add for a missing key ([Y/n], the developer's answer); other
hosts are the developer's opt-in through [ssh] host_extra in the host
profile, never the repository's dck.toml. ssh_host_config = false turns
it off.
Host accounts inside the container (host_profiles, opt-in)
With devcontainer-kit's host profiles a container's agents use the
developer's own ak accounts with no login inside — the way git already
works through the host's SSH agent. Both keys live in the developer's
host profile (~/.config/dck/profile.toml, [agents]), never in the
repository's dck.toml:
host_profiles = true(defaultfalse) binds, one by one, each hostakprofile ($AGENTKIT_PROFILES_DIR/<cli>/<name>) of the CLIs the repository installs ([agents] clis) whose profiles are file-portable (claude, codex, pi, cline, grok, opencode), and pointsAGENTKIT_PROFILES_DIRat them inside;host_profile_names(for example["claude@work1", "codex@default"]) limits the share to the profiles listed. A mount is read-write only where that CLI writes (its state, sessions, refreshed logins); never the whole agentkit home, never a whole CLI directory. Codex@defaultgets the host Codex home whencodex@defaultis shared. Cursor and Antigravity profiles are never shared (they hold absolute host links).- The container reads credentials from a host-generated env file (
0600), mounted read-only asAGENTKIT_ENV, holding only the Claude token of each shared Claude profile (CLAUDE_CODE_OAUTH_TOKENforclaude@default,CLAUDE_CODE_OAUTH_TOKEN_<SUFFIX>forclaude@<name>) and the exact names listed inhost_env_keys(default[], no prefixes or wildcards). Withhost_profilesoff nothing is copied. Claude authenticates through the profile's token, Codex through its auth file. Values never appear in compose, logs ordck doctor. - Folder trust for the app path is written in the container's homes and in
shared profiles. Claude's bypass-permissions acknowledgement is written by
the kit only in the container's own homes with autonomy on — never in a
shared host profile, and never with
AGENTKIT_PERMISSIONS=ask. A shared host profile needs that acknowledgement once from the developer on the host (ak claude @<name>, accept, exit); no agent sends keys for it (../../guide/orchestration-at-scale.md§16.5). - A shared Codex
auth.jsonis read-write: one active writer per account — do not run the same Codex account in two places at once.
Across restarts (v0.3.1). A second dck up keeps the shared tokens:
the env file is bound through its per-project directory and rewritten
atomically, so a running container sees the new file without
--recreate. A removed state volume no longer breaks dck ssh or the
Herdr machine: the container's host key is read from the container itself
and re-pinned, with a note. Logins kept on the state volume (gh, the
CLIs' own homes when not shared) survive bash dev.sh rebuild, but a fresh
state volume needs one gh auth login inside — the developer's step, never
an agent's.
Offer it only when the developer wants container lanes on host accounts
(../../guide/orchestration-at-scale.md §16.3); it widens what a container
can use, so say which profiles it shares and that a process in the container
can use those accounts and change their login files (the read-write
mounts). Setting it is the
developer's decision in their host profile — this addon describes it, never
sets it.
Host SSH keys ([ssh] copy_keys, v0.3.2, opt-in). Some tools read
only key files and ignore the forwarded agent (gh auth login offers to
generate a new key). The developer can turn on [ssh] copy_keys = true in
their host profile (dck setup asks once, default no; a repository's
dck.toml cannot set it). While it is on, dck up binds the whole host
~/.ssh read-only at ~/.ssh_host, and each container start copies its
id_* keys into the container's ~/.ssh on the state volume (0600, .pub
0644, kept in step with the host); agent forwarding is unchanged and
turning it off removes the copies. Name the cost when it comes up: every
file of the host ~/.ssh is readable inside, and private keys rest in the
state volume. Never set it, never answer that dck setup question.
One compose project, several services ([compose] state_volume,
v0.3.2). The state volume (sshd host key, ~/.ssh, gh auth, Herdr
client state, history) is named state by default. When the repository's
service shares a compose project (COMPOSE_PROJECT_NAME) with others, give
it its own name — state_volume in dck.toml or
dck init --state-volume NAME — or every service mounts the same
<project>_state volume; dck doctor flags it.
Rebuild and start (v0.3.2). bash dev.sh rebuild, dck start and
dck restart re-run dck up's post-start steps: the Herdr machine is
registered again (host key re-pinned), the mesh and host-catalog mirror are
pushed, the layout is created. A container rebuilt from scratch reaches the
host and its peers with no hand dck herdr mesh. The image also carries
coding-agents-kit's skills (agentkit, agentkit-setup,
agentkit-orchestrate), linked into every agent at each start.
Codex panes inside a container (v0.3.3). A Codex lane's commands run
from a per-profile server, so herdr-peers cannot probe its own machine and
needs HERDR_PEERS_SELF (the container's machine id as saved in the host's
Herdr catalog) for asks to the host or another machine. Since v0.3.3 dck
records that id on the state volume (dck up, after every dck herdr add,
and dck herdr mesh) and the login profile exports it, so no lane sets it
by hand; dck doctor shows both ids (herdr self) and flags a mismatch.
With an older kit, the lead's brief names the value and the lane sets it.
Since v0.3.4 the entrypoint also turns off Codex's startup update check
and its app-server daemon auto-start in the container's own Codex configs
(the kit pins every CLI version), never in the host's Codex home or a
host-shared profile, keeping any value the developer set; Codex's hook
trust stays the developer's consent.
The image also carries herdr-peers v1.0.0 (notices and lead records included), whose state is kept per Herdr
server, so a checkout bind-mounted into the container no longer shares the
host's state.
Shared compose stacks (v0.3.3, additive). When the repository is one
service of a product that runs as one compose project across several
repositories (an API, a web app, workers, a database), reason these keys
from the real stack — the kit's docs/shared-stack.md is the reference —
instead of hand-editing what dck renders:
[compose] project(the same value in every repository of the stack), onestate_volumeper service,[compose] networks(external) and[compose] volumeswith the top-leveluser:volumes/user:networkssub-blocks for the other services' data.- The user block —
# >>> user:<svc> >>>…# <<< user:<svc> <<<inside the dck service, kept verbatim: plain keys for what dck does not render (depends_on,healthcheck),x-dck-merge:for keys it does (lists appended, maps merged with the user's entry winning,commandandentrypointreplaced). Repository additions go there, never inside dck's own markers; a file with some of dck's markers but not all is refused. - Port strings:
ssh_portandportsaccept compose expressions such as"${API_HOST_PORT:-8000}:8000"; they stay loopback-prefixed unless the string names a host IP, which only the repository's own config may do. [build] context/[build] dockerfilefor a Dockerfile shared by several services,dev_sh = false(dck init --no-dev-sh) for a repository that keeps its owndev.sh, and[agents] presetsfor the ak alias presets.[agents] node_first = trueputs the agents' own Node (kept under/opt/dck/nodesincev0.3.3, never over the image's) first on PATH; off by default, set only when the repository's tooling needs it.
A repository that sets none of these renders byte-identically to v0.3.2.
Workspace satellites (v0.3.5). A repository whose scripts start a
second instance of its dev service (<svc>satellite, in its own compose
project with its own ports) starts it through dck, not plain
docker compose, so the satellite gets every host step the main service
gets (the authorized dck key, [ssh] copy_keys, host-profile accounts and
default_profile, the git identity, HERDR_PEERS_SELF, its own Herdr
machine dck-<project>-<service> on the mesh, the Codex/Claude container
config):
dck --project <P> --compose-file <main> --compose-file <overlay> --service <svc>satellite up [--seed-state-from <VOLUME>] [--label "<label>"]
dck --project <P> --compose-file <main> --compose-file <overlay> --service <svc>satellite down
Define the satellite after # <<< dck:service <<< in the main compose file
(extends: <svc>), or in an overlay file, where extends must name the
file (extends: {file: docker-compose.yaml, service: <svc>}); give it a
profiles: [satellite] entry and its own ports and volumes, never the main
state volume. --seed-state-from copies only the login state (gh,
Dailybot) once into an empty satellite state volume — never history, keys
or Herdr state. down removes only that service, its Herdr machine and
its SSH alias. The recipe is the kit's docs/shared-stack.md
(workspace satellites). Since v0.3.5 a workspace inside a renamed user's
home (user other than dev, workspace under /home/<user>) also builds.
Default account inside ([agents] default_profile, host profile).
{ claude = "@work3" } exports AGENTKIT_DEFAULT_PROFILE_<CLI> into the
container when that profile is shared, so a bare ak claude inside uses
that account (coding-agents-kit v0.5.2 and later); a macOS @default Claude login
lives in the Keychain and cannot be shared. It is the developer's host
profile key — describe it, never set it. Since v0.3.4, when it is set
and shared, the container's login shells also export CLAUDE_CONFIG_DIR /
CODEX_HOME for that profile, so a pane Herdr restores with a plain
claude --resume or codex resume opens on that account instead of a
login screen (a value ak sets wins). dev.sh also prints dck's refusals
(exit 5: a configuration that needs --trust, or markers to fix) on stdout. Since v0.3.3 the host's git
identity (name, email, SSH signing key reference) is pushed into the
container at every start, with no ~/.gitconfig mount.
Trust boundary (write scope)
allowed-tools includes write-capable Edit, Write, and Bash:
- Before consent: read-only.
command -v dck docker,dck doctor --json, and reading the repository's existing.devcontainer/,docker/anddev.shfiles. - Writes (only after explicit acceptance): the kit install (pinned tagged
clone +
install.sh), the repo-localdck-dockerfileskill (tag-pinnedskills add, recorded inskills-lock.json), the render in the repository — which shows a plan and diffs and changes an existing file only with consent, after a timestamped backup — theaddons.devcontainerregistry entry, and the validation record. - It MUST NOT: pass
dck init --yeswithout the developer's explicit acceptance of the shown diff; addprivileged,cap_add, host namespaces, the Docker socket or host bind mounts beyond the workspace and the SSH agent socket (never host~/.ssh,~/.gitconfigor${HOME}; the kit's read-only~/.ssh_hostbind exists only under the developer's own[ssh] copy_keys); publish a port beyond loopback unless the repository's own config says so; pass--truston the developer's behalf; copy a private key into an image or container, or set[ssh] copy_keysfor the developer; answer dck'sssh-addprompt or set[ssh] host_extrain the developer's host profile on their behalf; set[agents] host_profiles,host_env_keysordefault_profilethere for them, or print a shared credential's value; rundck herdr add(it edits~/.ssh/config) without its own explicit approval; install anything on the host beyond the kit and its skill; or write any secret value (.envfiles are0600and stay gitignored).
The flow
Step 0 — Detect (read-only)
command -v dck → dck doctor --json: interface must be 2 (otherwise one
warning and "not available"; a 1 means a kit older than v0.2.0 — offer the
upgrade; version 0.2.0 is unsupported since v0.2.1, its security
release — offer the upgrade too); read runtime (Docker/OrbStack/colima and Compose), repo (config
validity) and drift. Note an existing .devcontainer/, docker/ or
dev.sh — it will be reconciled, never replaced silently.
Step 1 — Offer (never impose)
Explain what it adds (one reproducible environment the developer and every
agent share, loopback-only ports, agent forwarding instead of private-key
copies, optional coding agents and DeepWorkPlan Vim inside) and what it
costs (Docker, an image build). Say that ssh_host_config is on by default:
the developer's git-host aliases, their public keys and trusted host keys
are copied in. Declining is complete.
Step 2 — Install the kit and its skill (pinned; point-don't-run by default)
git clone --branch v1.0.1 https://github.com/DailybotHQ/devcontainer-kit
./devcontainer-kit/install.sh
npx --yes skills add https://github.com/DailybotHQ/devcontainer-kit/tree/v1.0.1 --skill dck-dockerfile -y
Before running the installer, check the tag and the release's SHA256SUMS
(pinned digest, at least one file verified) as
../machine-installs.md shows.
The third line installs the dck-dockerfile skill into the repository
(repo-local, recorded in skills-lock.json), so "install the kit, ask the
agent" works in any coding agent. Run them yourself only interactively and
with explicit acceptance; re-detect afterwards.
Step 3 — Render the layout (reconcile, never clobber)
Hand the work to the dck-dockerfile skill: it detects the service name,
runtime, ports, the coding-agent CLIs to install (none unless named) and
extras such as chromium, shows them once for confirmation, renders through
dck init with the kit's pins, and never edits an existing file without
showing the diff and getting approval. Without the skill, reason the same
options (templates/INTEGRATION.md) and run dck init --dry-run … first,
then dck init … after acceptance.
Step 4 — Record and validate
python3 ../../shared/config.py enable devcontainer --version v1.0.1 --repo <repo>,
then validate what was rendered:
dck doctor --json— interface 2, repo config valid, no drift;- a real
docker build(the skill runs it; a failed build is a failed run, never a success), thenbash dev.sh up; - inside the container:
ak doctor --jsonreportspermissions: autowhen agents are installed (askwhen the documented opt-out is set — that is the expected result, never a failure to "fix"),nvim --headless +qaexits 0 when the editor is, and the repository's real test command runs.
Every result is recorded; none blocks a flow.
Autonomy inside the container. coding-agents-kit launches agents in
autonomy by default, which is what a disposable container is for: the
rendered compose sets nothing for permissions and carries a commented
AGENTKIT_PERMISSIONS=ask line as the documented opt-out.
Plan gates in the container (F-21). When the repository's real gates
run inside the container, a plan declares dck in
scope.allowed_command_classes and writes each gate check as
dck exec <service> -- <command> (a compound command: dck exec <service> -- bash -c '…').
A plan that recorded dck exec -- <command> (no service) is changed
through an explicit refine, never migrated silently.
ledger.py gate executes the wrapper itself, so the evidence stays
observed; validate-contract refuses a check whose wrapper is not
declared. Without the container the methodology is unchanged — the same
plan simply declares the host command instead.
Failure-mode guardrails
- Never required, never blocking. No Docker, no kit, an unknown interface, a declined diff, a failed build: record and continue on the host.
- Reconcile, don't clobber. Only consented, backed-up render changes touch existing files; nothing outside the kit's managed blocks moves.
- Vendor-neutral. No company network, volume, CLI or profile file is a
requirement; the Dailybot CLI layer appears only when the
dailybotaddon asks for it.
Validation checklist (component 4 — mirrored from SPEC §8)
SKILL.md,SPEC.md,addon.json,templates/INTEGRATION.mdexist; the descriptor pinsDailybotHQ/devcontainer-kitv1.0.1, interface 2; no template, Dockerfile, compose file, entrypoint ordev.shcopy ships here.dck doctor --jsonreports interface 2, a valid repo config and no drift.- Existing files were changed only through accepted render diffs, each with a backup.
- Ports bind loopback; no privileged options; no host
~/.ssh,~/.gitconfigor${HOME}mount proposed by the addon (the kit's read-only~/.ssh_hostbind exists only under the developer's own[ssh] copy_keys); no key material in the image. - The image builds for real, and the repository's real test command runs inside the container (or the failure is recorded).
Files in this skill
3deepworkplan-addon-devcontainer skill questions
How do I install the deepworkplan-addon-devcontainer skill in Claude Code?
Run npx degit DailybotHQ/deepworkplan-skill/.agents/skills/deepworkplan/addons/devcontainer ~/.claude/skills/deepworkplan-addon-devcontainer. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the deepworkplan-addon-devcontainer skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
What does this addon provide for a repository?
It provides a reproducible, isolated dev container that can be opened via terminal, VS Code, Cursor, or the devcontainer CLI.
Does this addon require a shared base image?
No, the Dockerfile starts from an official runtime image pinned by digest, meaning no shared base image is required.
How are host accounts and credentials handled inside the container?
Through opt-in host profiles, containers can use developer accounts (like Claude or Codex) via read-only mounts of specific profile directories and environment files, without copying private keys unless explicitly configured.