The dispatcher read the run, checked that the start it was delivering
was still the pending one, and reserved the execution grant in a later
transaction. A pause and a continue in between enqueued a newer start,
and the older one went ahead anyway: it took the run's execution
generation back and asked the provisioner for a sandbox for a
generation that had already been replaced.
Reserving the grant now checks the pending start again, in the
transaction that takes the generation, and refuses a replaced one with
START_SUPERSEDED. The dispatcher acknowledges such a start without
marking the run as waiting; the newer start proceeds as usual.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A build that stopped on an infrastructure fault, like the drops of the
POC's link to its cluster, repeated the whole protected verification
when continued: installation and every check, about two and a half
minutes on the POC, for a commit whose verdict could not change.
When the integrated commit is the verified checkpoint itself, the
verifier now reuses that verification evidence and only restores the
workspace for the build; the timeline says so. The control plane
offers only test and build evidence recorded under the current
protected policy, as a release requires: after the operator changes
the checks, the run verifies again. That also keeps an executor that
continues at the release stage from requesting a release with
evidence the release would refuse.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The agent's file tools are confined to its workspace, and the
workspace holds .git. It could plant .git/config and .gitattributes
there, and the executor then ran trusted git add, diff, bundle and
merge in that workspace to export the checkpoint and start a repair
round. Git honours repo-local configuration for every command and no
environment variable disables it, so a planted clean or smudge filter,
diff or merge driver, core.fsmonitor or sshCommand, an include, or a
url.insteadOf transport rewrite would run as the worker: in the
development host mode, as the operator, outside any sandbox. The
driver names are the agent's to choose, so -c overrides cannot reach
them.
Before the checkpoint and before mergeTarget, .git/config is now
reduced to core basics, remote, branch and extensions, which is what a
clone needs to fetch, merge and bundle; everything else, the planted
drivers and includes among it, is dropped. It is redone each time,
since a paused run's agent could plant again before it resumes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In the development host mode, protected checks and dependency
installations ran directly as the operator. They run the agent's code:
a test it wrote could read the home directory's secrets, reach the
network, or plant Git configuration that the trusted Git commands after
it would execute.
With WF_HOST_CHECK_SANDBOX=true they run under Seatbelt instead. File
contents in the home directory are unreadable except the command's own
directory and the paths the operator lists; it may write only there,
in the caches the operator lists and in a temporary directory of its
own, never in a .git directory. Only installations reach the network;
checks may use loopback ports by opt-in, for test suites that start
local servers. The platform's own ports (control plane, Temporal and
its web UI, database, object storage, provisioner, Git service, IDE,
console) stay blocked in any case: the local start lists them from
their configured addresses. Checks get no answer from the keychain,
and a command whose home is the executor's (holding its credentials)
gets a private one. A sandbox that cannot start leaves the run waiting
on infrastructure; verification evidence records checkSandbox.
scripts/check-host-check-sandbox.ts checks all of this on the target
Mac, from outside the sandbox, then runs the POC's installation and
checks sandboxed on a recent droboticflow source. Enabled on the local
POC, a real wish passed through both, including a repair round for the
agent's own failing tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every protected web build archived the build it replaced and never
removed one, at 50 to 200 MB each: the local POC had collected 284 MB
in three backups. A successful build now keeps the build it replaced,
which the receipt names as the rollback target, one earlier build and
the newest failed build; the receipt lists what it removed. Removal is
best effort: a directory it cannot remove waits for the next build.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The public checks after a POC rollout (health, readiness, the entry
page, the API build commit and the protected smoke checks) were each
made once. Just after a rollout the public address can still reach a
Pod that is shutting down, which answers with the old build commit, and
the link can drop: either failed a healthy release and rolled it back.
They now take up to six attempts, waiting 2 to 10 seconds; a release
whose checks never pass is still rolled back.
Retries were also silent: a build slowed down by a flaky link looked
stuck. Every repeat now says what went unanswered and when the next
attempt comes, in the run's timeline during a build and in the Runner's
log during a release. Requests and checks share one retry helper.
The third live test found kubectl cp and exec reporting a failed dial
as "error: dial tcp ...: connect: operation timed out", without the
"Unable to connect to the server" of get. That upload was not retried
and the build stopped; dial failures and connection timeouts now count
as unanswered, checked against the messages seen on the POC link.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Runner only ever logged errors, as JSON lines without a time, so
its log could not be lined up with a run's timeline: during the
2026-10-26 POC tests the connection errors of every service restart
looked like current failures, and a release left no trace at all.
Each line now carries its time and level. The Runner records when it
takes a task, and how the task ended with how long it took: the task,
action and release IDs, the outcome and the seconds. These are read
defensively before the signature check, which a malformed task must
still reach; payloads, arguments and credentials are never logged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In the 2026-10-26 POC run the Mac's link to the cluster API dropped
about once a minute. One unanswered kubectl call ended the whole build
twice, though the Kaniko Pod kept building, and each manual resume
re-ran the protected verification. The release path had the same
weakness with worse consequences: a dropped rollout watch counted as a
failed rollout and rolled a healthy release back.
Only requests that are safe to repeat are repeated, and only when the
cluster API left them unanswered (no connection, a broken connection,
kubectl hung), never when it refused them:
- Reads take up to six attempts, waiting 2 to 30 seconds between them.
- The builder looks its Pod up by its attempt-unique name before each
create, adopting a Pod whose create answer was lost.
- A lost source upload is sent again. Unpacking runs once at a time,
refuses an upload whose SHA-256 differs from the archive, and marks
the context ready only when complete, so Kaniko never starts from a
partial context; a damaged upload is sent again.
- A dropped rollout watch resumes for the rest of the rollout timeout.
Patches are still never repeated. A link that stays down longer still
stops the run as an infrastructure fault.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude Code and CodeBuddy report a session's usage only in their final
result. A session stopped before it (paused, canceled or out of time)
reported nothing, so its tokens never reached the run's budget or the
monthly plan: the paused session of the 2026-10-26 POC run was recorded
as 0 tokens, and repeated pauses could have spent without limit.
The adapter now adds up the usage each model response carries in the
stream, once per response although the CLI repeats it on every content
block, and reports that as the session's final usage when no total
arrives. The executor meters it like any final usage; the timeline
marks it as estimated, since the last response's output may be
undercounted.
The final result usually repeats the agent's last message word for
word, which the timeline then showed twice; it is now shown once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Eight wrong passwords from anywhere on the network locked the only
local administrator out for fifteen minutes, again and again. The
password is 256 random bits, so the limit only has to bound the
scrypt work: after eight failures, checks are spaced two seconds
apart, globally, and a burst cannot run them at once.
- The launcher let the Next.js development server listen on the LAN,
handing every visitor its source maps and hot-reload channel. Only
the production build may now listen beyond loopback. A listener
bound to one address is also checked for readiness there, and the
banner shows the configured port.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Pausing revoked the executor at once: the agent was killed and the work
of the current attempt stayed only in the executor's local workspace,
so continuing started that attempt over.
A pause of a run whose executor holds the lease now drains it first:
- The run keeps `running` with pauseRequestedAt (the console shows
pausing). Its agent gets no model credential and no new model
request; continuing is refused until the pause completes; cancelling
still stops it at once.
- The executor learns of it from its heartbeat, stops the agent, saves
a checkpoint with its live lease and completes the pause through
/internal/runs/:id/pause. Continuing restores that checkpoint.
- The workflow is stopped only after the pause completes; stopping it
earlier would abort the save. A model request interrupted by the
stop no longer expires the pausing run's lease.
- If the executor does not complete it within two minutes, or stopped,
the heartbeat, the next lease, the coordinator's wait or the
background sweep pause the run anyway.
Runs no executor is working on still pause at once.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- The runner took the newest ready release and threw when it was
stale, on every poll, so nothing else in the environment deployed.
Polling now fails stale ready releases (canceled runs, revised
requirements, changed code, configuration or approval), tells their
runs, and deploys the next one. A paused run's release waits, since
continuing may make it current again.
- A rollback the runner reported as failed stayed unknown and held the
environment, which neither unlock nor another rollback could free. A
definite failure now frees it; an unknown rollback can be unlocked by
an owner or admin after checking the target, which cancels it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every failed installation waited as an infrastructure fault. When the
agent's own change broke it (a misspelled package, say), continuing
installed the same manifests before the agent ran, failed again, and
the agent never got a turn: the run could not move without a new
requirement revision.
- The verifier attributes a failed installation to the checkpoint when
it changed dependency manifests (package.json, go.mod, lockfiles and
the like) and the output is not a network or registry failure. The
evidence lists those manifests, and the control plane records an
`install` failure that the next repair round fixes.
- A repair round for an `install` failure starts the agent even when
the installation fails again, with that output in the prompt.
- Prompts, lessons and the run page name the failed installation.
Any other failed installation still waits for the environment, without
spending a repair round.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
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>
The proxy aborted every upstream call 120 seconds after it started, even
while the model was still streaming, so a long reasoning turn ended as an
unknown outcome that an admin had to reconcile. Calls now stop only when
no bytes arrive for 2 minutes, or after 10 minutes in total, inside the
15 minutes after which the reaper treats a request as lost. The recorded
reason says which limit stopped it.
A rejected request (a 429, an invalid request, or one stopped before
upstream I/O) was stored and replayed for every retry of the same body,
so one rate limit stalled the run for the rest of its lease. Rejections
use no tokens, so a retry is now sent again; completed responses are
still replayed and unknown outcomes still wait for reconciliation.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Reproduce and fix the launchd SIGTERMed shutdown race; wait for owned processes to exit and report timeouts. Describe local task workspaces without claiming OS isolation.
Detect actual service and Runner readiness, restore LAN access after network changes, protect production web builds with rollback, honor cancellation during executor startup, and show truthful cached-data and credential states.
Add authenticated LAN access, native Claude execution, checkpoint and budget recovery, and signed POC build/deploy/rollback contracts. Include local service management, regression coverage, and evidence from the completed POC delivery.
Repeated builds grew the VM's disk to 63 GB, until the Mac's disk was
full. Writes inside the VM then failed and its file systems broke.
- The service image installed dependencies after copying every source
file, so each source change rebuilt a 750 MB layer, five images at a
time. It now installs from the workspace manifests first, and a test
keeps every workspace listed.
- The VM's disk defaults to 40 GiB instead of 80.
- `up` refuses to create the VM when the Mac has less free space than
that, and `build` refuses below 15 GiB free.
- After building, superseded images are pruned and the build cache is
capped at 10 GB.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The local cluster deploys the IDE gateway, and the provisioner creates a
Theia workspace with an OCT sidecar per project in the tenant namespace.
`build` adds the ide, ide-gateway and oct-workspace images; `web`
forwards the workbench (3100) and the gateway (3101).
- On a local development cluster (WF_ALLOW_INSECURE_HTTP), the
provisioner accepts the in-cluster HTTP platform Git and the localhost
gateway for workspaces.
- Builds use a proxy from the host environment, at the address the VM
sees the host at.
- `web` refuses ports already taken on the host, where kubectl would
otherwise listen on ::1 only. Its defaults stay clear of the local
development stack (3000, 4400).
- Pods reading the settings or secrets carry a digest of them, so a
redeploy with changed settings rolls them.
- The IDE build context leaves out every local node_modules.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The local cluster runs the workbench next to the API. It is a development
build of the web, from the image's new WEB_BUILD=development argument:
- Next.js inlines NODE_ENV into production builds.
- Development sign-in therefore exists only in development builds, and
production images never carry it.
`node scripts/k3s-local.mjs web` forwards it to http://localhost:3000. The
web refuses changes from any origin but its WF_PUBLIC_URL, so that address
is set at deploy time (WF_K3S_WEB_PORT). `build` now also takes the images
to rebuild, for example `build web`.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Building the web image showed that `next build` failed.
- The console imported runtime values from the contracts entry point.
- Turbopack cannot follow the NodeNext `.js` imports inside that entry,
which also carries zod and every schema into the browser.
- Only `next dev` had ever run before, and the console used to import
types only.
The fix:
- The executor catalog moves to an entry without imports, exported as
@wishforge/contracts/providers. The console takes its values from
there.
- providerBaseUrl moves to its own module.
- A test keeps value imports of the entry point out of the console.
With the console's default budget of 50,000 tokens, every Codex run
stopped after one model request:
- The proxy reserves one token per request byte, and a Codex request is
already about 50 KB.
- The executor then reported a bare 429 as a provider failure.
The fix:
- A request the remaining budget cannot cover now puts the run into the
`budget` wait, with what it needs and what remains.
- The console defaults to 300,000 tokens and explains the reservation.
The run page also marked the stage a successful run ended in as not yet
done; it now shows it as complete.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The first runs on k3s found these problems; a wish now goes from submission
through the Codex executor, independent verification and integration in
per-run pods.
- Development deployments refused to start because the images set
NODE_ENV=production. The local manifest and the sandbox Jobs now set
NODE_ENV to the deployment mode.
- The model proxy treated x-client-request-id as a per-request idempotency
key. Codex sends its conversation id there, so every second request of a
session failed with 409. Only Idempotency-Key names a single request now.
- Codex's command sandbox (bubblewrap) cannot start in a runc pod. Every
command failed and the agent retried until the budget ran out. The
executor now probes the sandbox before starting Codex. A Kata sandbox that
cannot run it waits as PROVIDER_SANDBOX_UNAVAILABLE. A development (host)
sandbox runs Codex without it, and the timeline records that.
- The prompt asked agents to commit, but Codex keeps .git read-only and the
platform commits the checkpoint itself. Agents now leave their changes
uncommitted, and get the platform's Git identity if they commit anyway. A
resolved merge is recorded even when its tree equals HEAD.
- scripts/k3s-local.mjs:
- excludes the VM and cluster ranges from a host proxy (NO_PROXY);
- uses its own Docker client configuration, so a stale credential
helper does not break builds;
- recovers from an interrupted k3s install;
- reports when Colima switches the current kubectl or Docker context.
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>
Released generations kept their PVCs (and the local backend its run
directories) forever, filling the tenant quota.
- The API's hourly maintenance asks the provisioner to purge the volumes of
every generation of a run once WF_RUN_STORAGE_RETENTION_HOURS (default a
week, 0 keeps them) passed since the release, and records storagePurgedAt.
Checkpoints live in the control plane, so continuing a run never needs them.
- POST /runs/purge deletes the run's PVCs by label (the local backend its
directories) and answers busy while any of the run's pods or processes is
active. The baseline Role gains list and delete on PVCs.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
In Kubernetes mode the per-run network policy allowed only DNS, the API,
Temporal and Git, so dependency installs could not reach a registry and image
builds had no builder.
- WF_RUN_INSTALL_PROXY_URL points both sandboxes at an operator's egress proxy
(pods labelled egress-proxy); the per-run policy admits it and installation
commands get HTTP(S)_PROXY, also inside bubblewrap, while checks still have
no network.
- WF_VERIFIER_DOCKER_HOST with a TLS client certificate points the verifier at
a remote builder daemon (pods labelled image-builder); a separate policy
lets only the verifier pod reach it, and release deletes that policy too.
Builds pass DOCKER_HOST, DOCKER_TLS_VERIFY and DOCKER_CERT_PATH, and refuse
a Docker context and a remote builder together.
- The control namespace's baseline admits sandbox traffic to both components.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Sandboxes can reach Temporal, which used to accept any client in one shared
namespace. Now:
- Every Temporal client (API dispatcher, coordinator, deployer, sandboxes) can
present a client certificate (TEMPORAL_TLS_*); production refuses to start
without one.
- TEMPORAL_NAMESPACE_PREFIX gives each tenant its own namespace: the dispatcher
starts and signals a tenant's workflows there, the shared coordinator and
deployer poll every served tenant's namespace with one workflow bundle, and a
sandbox polls only its tenant's. Production refuses to serve several tenants
through one namespace.
- The Kubernetes provisioner mounts the tenant's Temporal client certificate
into executor and verifier pods (WF_RUN_TEMPORAL_TLS_SECRET, required in
production); the local provisioner passes the TLS settings through.
Authorizing certificates per namespace remains Temporal server configuration;
the operations guide describes it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A first implementation round may end, without changing any files, with a
QUESTIONS: section of up to five questions. The executor then puts the run in
the clarification wait with the questions in its detail, where the console and
MCP show them; answering already creates a new requirement revision that
starts again from planning. Repair rounds cannot ask: they must fix what the
verifier found.
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>
Verification ran git inside the tree under test, kept no command output and
treated every infrastructure fault as a test failure; repairs went through an
executor lease the coordinator should not hold; and a project without delivery
could never succeed. This reworks the worker execution path and the control-plane
contracts it depends on.
- Verification exports the exact commit to a directory without .git, installs
dependencies (network allowed) and runs the protected commands under
bubblewrap in kata mode or directly in host mode; evidence records exit code,
duration, digest, a redacted output tail and the isolation used. Production
rejects host evidence. A failed installation waits as infrastructure.
- Waiting reasons are an enum with a redacted detail; dispatcher, GitHub and
model-proxy states map onto it, and the console explains each one with a way out.
- Repairs are requested by the coordinator through /internal/runs/:id/repair;
the control plane derives the failure summary from the verifier's evidence and
enforces the repair budget. Continuing after the budget is spent grants one more
round; a new requirement revision starts a fresh budget.
- Execution identities may only move a run within their own stages and only to
running or waiting; success comes from integration evidence (no delivery
configured) or deployment acceptance. The unused preview stage is gone.
- Integration fast-forwards when the target has not moved, merges and re-verifies
otherwise, retries when a push finds the target moved, and turns merge conflicts
into a repair round that merges the current target for the agent to resolve.
- Successful runs that needed a repair leave a project lesson; active lessons are
injected into later prompts, and admins can list, add, disable and delete them.
- Executor progress (messages, commands, file changes, plan updates) is stored as
normalized events; previously agent messages were recorded as the literal word
"output". Provider failures keep the work as a checkpoint and wait as
provider_error instead of failing the run.
- Workers declare WF_SANDBOX_MODE=host|kata (host refused in production),
heartbeat with retries until the lease could have expired, and retry safe
control-plane reads with backoff.
- tests/local-loop.test.ts runs the loop end to end with real Git, the in-process
control plane behind its internal routes and a scripted agent.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The invoice/settlement flow produced statements whose every monetary
field was null, behind a review/settle/void ceremony. Model charges are
billed by the provider directly, so the platform only needs to report
measured usage.
- apps/api/src/domain/usage.ts replaces billing.ts: per-month usage
lines, totals, model-measurement coverage and a formula-safe CSV
export. No invoice digest, settlement records or billing entities.
- Routes: GET /v1/usage/lines and /v1/usage/export (owner/admin),
GET /v1/plans; platform-operator actions move to
POST /v1/admin/members and /v1/admin/executions/:id/reconcile.
The operator allow-list is now WF_OPERATOR_SUBJECTS.
- Contracts: UsageLine replaces BillingUsageLine/BillingInvoice; the
billing_event and billing_period entity kinds are removed.
- Web usage page shows limits, occupancy, monthly totals and lines.
- npm script tenant:invite is renamed tenant:create (it provisions a
tenant).
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>
- docs/requirements.md is now the single source of product scope:
positioning, glossary, an explicit definition of RSI (in-task
self-repair, project lessons, versioned agent configuration with
human promotion), roles, core journeys, prioritized functional
requirements with acceptance criteria, non-functional requirements,
explicit non-goals and milestones.
- Remove implementation-status-2026-10-17.md and
acceptance-traceability.md. They were dated evidence logs pointing at
machine-local /private/tmp files and referenced undefined "P0-P5"
priorities; requirement-to-test traceability moves into the
architecture document's verification matrix.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Imports the previously untracked working tree as-is so that the review
changes that follow (requirements -> design -> implementation) can be
reviewed as diffs and reverted if needed. No content changes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>