Stopping dev.mjs sent SIGTERM to each service and moved on, so a slow
service, or anything a service spawned (run workers, Next.js workers),
outlived it once the supervisor killed dev.mjs after 20 seconds. The
next start then found the old API answering and reused it: a rebuild
kept running old code.
- Each service runs in its own process group. Stopping signals the
group, waits up to 10 seconds, then kills what remains.
- Under the LaunchAgent supervisor, a service already answering is
refused instead of adopted (WF_LOCAL_REUSE_SERVICES=false).
- npm test, and so CI, now runs scripts/*.test.mjs. The POC check test
that needs the Mac's Homebrew toolchain skips where there is none.
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>
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>
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>
Sandbox Jobs never received WF_DEPLOYMENT_MODE, which every worker requires
before anything else, so each Kubernetes sandbox exited at start. The
provisioner now passes its own mode.
A local development cluster (k3s) has no Kata, no bubblewrap inside runc and no
TLS between services. For it, and only with WF_DEPLOYMENT_MODE=development:
- WF_ALLOW_INSECURE_HTTP=true lets services reach each other over plain HTTP
(Git, the model proxy, the provisioner and IDE gateway targets, the worker's
control-plane client); production refuses the setting outright.
- The provisioner accepts WF_RUN_SANDBOX_MODE=host and WF_KATA_RUNTIME_CLASS=none
and passes the HTTP settings to its sandboxes.
- The development seed is built into the image (dist/api/seed.mjs).
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>
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>
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>
- Storage: read-only queries use a read-only transaction without the tenant
lock, so event streams and dashboards no longer queue behind writers; lists
filter on indexed project, run and status fields and the run list pages with
limit/before. Dispatchers claim outbox items with SKIP LOCKED and a claim
deadline; delivered items and old idempotency records are pruned hourly.
- Migrations are versioned files recorded with checksums in schema_migrations;
002 adds the claim column and run index and migrates preview-stage runs and
free-text waiting reasons. Run events and usage are append-only for the app.
- Identities: static service tokens reach only their routes (coordinator: state,
wait, repair; deployer: lease, transition, releases); the static verifier
identity is gone; Git credentials go only to the lease holder; internal bodies
are validated; framework and body-parser errors use the API error envelope.
- Quotas: only queued or running runs (or ones with an unsettled model request)
hold token reservations; continuing a run reserves its remaining budget again.
- Recovery: owners can list and reconcile model requests with an unknown outcome,
and requests whose proxy died are marked unknown; definite deployment failures
free the environment, admins can unlock an environment after checking the
target, approvals expire with their release, and production approvals need a
second person. The builder's Docker context is operator configuration.
- MCP: list_projects, absolute console links, request_release resolves the run's
evidence and default environment, and tool changes are audited as the user.
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>
Security-relevant behaviour (development tokens, loopback HTTP, inline
checkpoints, raw provider keys, optional verification profiles) was
keyed off NODE_ENV === 'production', so any deployment that forgot
NODE_ENV silently ran with development rules.
- @wishforge/contracts exports deploymentMode/isProduction/
requireDeploymentMode. WF_DEPLOYMENT_MODE wins; misspelled values and
development combined with NODE_ENV=production are rejected; NODE_ENV
remains a fallback only for libraries and tests.
- All API, runtime, artifact, Git service and operator-script checks use
isProduction.
- The API, worker, Git service and Runner refuse to start without an
explicit WF_DEPLOYMENT_MODE; the IDE gateway treats anything other
than an explicit development mode as production.
- The development seed loads .env.local before checking the mode.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The IDE carried a second, Theia-internal coordination system: multi-
client save barriers, a hash-chained snapshot store, IndexedDB draft
recovery, transferable debugger-control leases that intercepted
Theia's plugin RPC, Ed25519 actor assertions from the gateway, and an
API gate that blocked every agent integration while any IDE workspace
was open until a human imported a coordinated snapshot. It depended on
Theia internals, made F5 debugging require five environment variables
plus a gateway-signed header, and stalled agent runs. IDE and agents
now hand off through Git commits (docs/architecture.md ADR-7).
- Delete apps/ide/coordination, apps/ide/security, the policy
extension's coordination/draft/DAP-guard/lifecycle-safety modules and
the unused product.json; the policy extension keeps only the managed
extension allow-list and scoped collaboration.
- API: workspace snapshot import/match/check routes are gone. The
project integration lease (one integrating run per project, fenced)
moves to domain/integration-lease.ts and is still enforced on
integrate/build transitions and build evidence.
- Workspace lifecycle: pause/resume no longer requires a save barrier;
automatic sleep needs 30 idle minutes and zero gateway connections,
which the gateway now reports itself. The lifecycle/integration
authorize relays and the gateway's assertion signing are removed;
gateway edit roles match the contract roles.
- Worker: no snapshot matching, workspace-input gate or local lock
file during integration; runtime workspace-snapshot is removed.
- Web: the snapshot import panel is removed from run detail.
- Provisioner workspaces no longer mount coordination state or the
gateway public key; local setup no longer generates gateway keys.
The local Theia build under apps/ide/lib must be rebuilt to pick up the
slimmer policy extension.
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>
The meta-evolution machinery (failure clustering meta-tasks, signed
offline evaluation, shadow/canary stages, external release receipts,
evaluator identity and its UI) could never take effect: promotions were
written to the system tenant only, the benchmark/runner/observer it
depended on did not exist, and its statistical gates were effectively
unreachable. It is removed as agreed in docs/requirements.md section 3.
What remains is the part every run actually uses, now explicit:
- packages/evolution becomes packages/agent and keeps only the bundle
schema, content digest and prompt assembly; consumers import it as the
@wishforge/agent workspace package instead of by relative path.
- apps/api/src/domain/agent-bundles.ts: immutable, content-addressed
agent configurations per tenant, with create, activate and rollback
restricted to human owners/admins. A run pins the active version at
submission; later activations never change it.
- /v1/agent-bundles routes replace /v1/evolution*; all /internal
evolution routes, the evaluator service token and the rsi:rollout
script are gone.
- Web: the experiment page becomes an "Agent 配置" page.
- Tests for the deleted modules are removed; control-plane tests cover
version pinning, rollback and authorization.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Adds prettier 3.9.8 (exact) with a shared config (single quotes,
120 columns, trailing commas), .prettierignore, .editorconfig and the
`format` / `format:check` scripts, then formats all TypeScript,
JavaScript, CSS, JSON and YAML sources.
Purely mechanical: no behaviour change. Typecheck passes, the vitest
suite and the 74 IDE node tests produce the same results as before
(socket-binding tests still cannot run inside this sandbox).
Previously the longest source line was ~3000 characters; reviewing the
following semantic changes now produces readable diffs.
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>