With WF_CLAUDE_COMMAND_SANDBOX=true, Claude Code also gets Bash, run in
its built-in sandbox through --settings:
- The sandbox must start (failIfUnavailable), and no command may run
outside it (allowUnsandboxedCommands: false).
- No network: an empty allowedDomains with strictAllowlist, since an
absent allowlist leaves the network open. Local binding stays off,
because it would also open every local port, Temporal's included.
- Commands cannot read the home directories, the CLI's home or the
worker's own directory, except the workspace, a per-run scratch
directory and WF_CLAUDE_COMMAND_READ_PATHS; they write only to the
workspace and the scratch directory; credential variables are unset.
- WF_CLAUDE_COMMAND_ENV gives commands toolchain variables, such as the
POC's read-only Go module cache.
The executor probes the sandbox first (Seatbelt on macOS; bubblewrap
and socat on Linux) and keeps file tools only where it cannot start,
saying so on the timeline. The adapter now writes the execution
contract into the prompt, for the tools the agent actually has.
scripts/check-claude-command-sandbox.ts checks a machine with one short
real session and judges each probe by its effect, not the agent's
account. On the local Mac every probe was blocked; the login keychain
remains reachable, because Claude Code's Seatbelt profile always allows
the security server. That limit is documented.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude Code with a tenant key started with bypassPermissions and every
tool, Bash included, and loaded the repository's settings, hooks and MCP
servers. It now runs like the native development login already did:
restricted mode with dontAsk, only Read/Edit/Write/Glob/Grep, confined to
the workspace, and no repository or user settings. Every Claude Code run
is told the verifier runs installs and tests.
CodeBuddy's agent runs commands with no sandbox of its own. Like Codex
without its sandbox, it now starts only in a development (host) sandbox,
says so on the timeline, and stops with PROVIDER_SANDBOX_UNAVAILABLE on
Kata.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
infra/k8s/local describes a development cluster in a Colima VM: PostgreSQL,
Temporal, the platform Git service, the API (migrating and seeding in init
containers), the coordinator and deployer workers, and the Kubernetes
provisioner with a service-account kubeconfig, a Role in the tenant namespace
and a default-deny policy there. Wishes run in per-run pods under the
provisioner's network policies, and models are reached through the API's
run-scoped proxy and the configured gateway.
scripts/k3s-local.mjs starts the VM and a local registry, builds and pushes the
images by digest, renders the manifest with generated secrets kept in
.wishforge/k3s, stores the gateway key over stdin, and runs a smoke wish. Every
command names the colima-wishforge context, never the current one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The model proxy always forwarded to api.openai.com and development runs gave
Codex no base URL or model, so a company model gateway could not be used.
- WF_OPENAI_BASE_URL points the production proxy (and development Codex runs)
at an OpenAI-compatible gateway with the Responses API; WF_ANTHROPIC_BASE_URL
gives Claude Code an Anthropic-compatible one as ANTHROPIC_BASE_URL. Both are
operator settings in the provider catalog, HTTPS without credentials
(loopback HTTP outside production); an invalid gateway disables the proxy.
- Development credentials now carry the run's model, so WF_CODEX_DEFAULT_MODEL
selects a model the gateway serves.
- tests/integration/real-model.test.ts (WF_REAL_MODEL_INTEGRATION=1, key from
WF_TEST_MODEL_API_KEY) runs one wish through the real Codex executor, the
verifier and integration into a local repository.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Adding an executor touched the contracts, the API's availability check, the
worker and the console separately. Now it is an adapter plus one entry in
@wishforge/contracts' providerCatalog (name, executable variable, whether the
model proxy isolates its credentials) and one in the worker's
providerRegistry; the API, the console's options and MCP's submit_wish read
the catalog, and a test checks every entry is registered with the worker.
The CodeBuddy adapter already parsed Claude-Code-style stream-json, so it is
now a StreamJsonCliAdapter with a dialect per CLI. Claude Code runs headless
with --verbose and --permission-mode bypassPermissions inside the per-run
sandbox and receives only ANTHROPIC_* credentials (WF_CLAUDE_BIN). Like
CodeBuddy it is development-only until the model proxy supports it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
scripts/build-services.mjs compiles the API, its migration runner, the worker,
the Runner and the platform Git service into single ESM files under dist/.
Workspace packages are compiled in, everything else loads from node_modules,
and esbuild applies the transform tsx applied before, so behaviour does not
change. The Temporal workflow bundle is built at the same time and the worker
uses it when present instead of bundling at start-up.
The runtime image builds the services and runs dist/*/main.mjs; the
Kubernetes provisioner starts sandboxes with dist/worker/main.mjs, and
migrations run as node dist/api/migrate.mjs. esbuild is now a declared dev
dependency. A test builds everything and checks that each entry point loads
all its imports and reaches its own configuration checks.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
People's changes now reach the target branch the same way the agent's do. The
IDE credential carries a ref prefix and the Git service runs a pre-receive hook
on every push that refuses updates outside it, so the IDE can push only
`ide/` branches; the platform's own integration is unaffected.
- A wish may name a source branch. The run starts from that branch's head, the
agent builds on it, and verification, repair rounds, merging onto a moved
target and conflict repair work as before. A missing branch makes the run
wait (git_storage) until it is pushed.
- Release risk is now computed from the target branch before integration, not
from where the run started: a migration committed on the source branch would
otherwise have been missed and could have skipped approval.
- Clones work on `ide/work`; a plain `git push` publishes it.
- The console lists a project's IDE branches with a button to submit a wish
that merges one, and the new-wish form has a starting-point field; MCP
`submit_wish` accepts `sourceBranch`. The Git service lists branches under
a prefix for this (`POST /refs`).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
While someone has a workspace open, the gateway asks the API for a 15-minute
write token for the project's platform repository on behalf of that person
(membership and role checked each time) and delivers it to the workspace
backend. The backend writes it to a Git config file outside the repository
(a memory volume in Kubernetes) that the clone includes, and on the first
delivery clones the target branch into a folder named after the project. The
workspace cannot mint credentials itself, so access ends with the last
session.
- People commit and push to the target branch like with any Git server; the
platform only accepts fast-forwards, and the next wish starts from that
commit (covered end to end in the local loop test).
- Commits are authored by whoever opened the latest session, from the name and
email in their sign-in; their own git config overrides it.
- Only the gateway can reach the delivery endpoint: it needs Theia's
connection token, and the gateway refuses the path for browsers.
- The provisioner pins the workspace to its repository and lets the pod reach
the Git service; the Kubernetes baseline admits that traffic. External
repositories are not cloned.
- The local shared Theia clones each project into its own folder.
- The Theia image installs Git, and its stage is named theia: the default
build target of that Dockerfile is the gateway.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Operations, development and architecture docs, the reference pages and the
component READMEs were rewritten against the code: every documented variable
exists, and the settings operators need (runtime image, Git service, listen
addresses, Runner targets, single-tenant gateway and provisioner bindings) are
documented.
Gaps the docs used to present as working are now stated as such: IDE
workspaces do not clone the project yet (FR-H2), and in Kubernetes mode
dependency installs and image builds have no network path until an egress
proxy and builder access exist. The Kubernetes README describes what the
provisioner creates, what the Runner needs in a target namespace, and the
cluster acceptance that is still outstanding.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Local development had no provisioner, so every wish stopped at "sandbox not
ready", and dev:all started neither the coordinator nor the deployer.
- The provisioner moves from apps/ide to apps/provisioner and gains a backend
switch: `local` starts an executor and a verifier process per run generation
on this host (WF_SANDBOX_MODE=host, own directories and run-scoped tokens,
development mode only) and points workspaces at the local Theia; `kubernetes`
keeps the Kata Jobs, now started with the image entrypoint instead of the npm dev
script and allowed to reach the platform Git service.
- In development the resource grant needs no runtime image digest.
- setup:local is one idempotent script that creates or completes .env.local,
including the deployment mode, provisioner and grant settings.
- dev:all starts Git, API, provisioner, coordinator, deployer and web; dev:ide
starts Theia and the IDE gateway; ide:install and ide:build wrap the separate
Theia package. npm test also runs the provisioner tests.
- Project settings accept the target branch and dependency install commands.
- Web development conveniences require WF_DEPLOYMENT_MODE=development.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- docs/architecture.md replaces system-design.md: component map,
run state machine with an explicit waiting-reason catalogue, key
sequences (dispatch, execute/verify/repair, integrate, release,
IDE launch, lessons), data model, API surface, identity and trust
model, isolation modes (host for local development, kata for
production), deployment topology, ADRs, known limitations and a
requirement-to-test verification matrix.
- docs/development.md: local setup, one-command start, first wish,
IDE, MCP and the test matrix (integration toggles are explicit).
- docs/operations.md: production prerequisites, explicit deployment
mode, component configuration, Kubernetes provisioner, tenants and
quotas, IDE gateway routing and lifecycle, delivery, monitoring,
backup/restore, incident handling and known risks. Merges the former
observability, recovery, billing-entitlements and runbook documents.
- Contract documents move to docs/reference/; evidence narratives that
pointed at machine-local /private/tmp files are removed and the UI
reference is rewritten for the target console.
- Delete docs for removed scope: workspace snapshot handoff and private
application access.
- README rewritten as a concise entry point.
The documents describe the target state that the following
implementation commits realise.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>