Brings the branch up to the current base (executor settings, project
skills, Chinese run messages, cloud IDE removal, wish attachments) and
resolves the ten conflicted files, keeping both sides:
- wish-refiner: the tenant's executor settings pick the models first,
then the Copilot model setting; the tenant credential still goes
before the operator's login
- worker providers: executor settings apply, and a run with its own
credential still gets an empty home
- main.ts: Copilot screenshot uploads and wish attachments each keep
their own body limit
- contracts, http, web types: default budget and skill auto-activation,
Copilot and attachment entity kinds, ./text and ./attachments exports
- globals.css: Copilot styles and attachment styles, one after the other
- tests: the canceled-release reason is Chinese; the refiner's default
models have no [1m] suffix, as this branch names them
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Resolved against the IDE removal and the lessons-to-skills merge; the
pitfall skills, their events and repair notes are written in Chinese too.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The cluster never ran Theia or the IDE gateway, so every workspace stayed
"未配置" forever. The feature is gone instead of half-present:
- API: workspace, launch and lifecycle endpoints, the gateway identity and
its internal routes, the dispatcher's workspace provisioning and the
lifecycle worker. Migration 003 deletes stored workspaces and settles
their pending outbox items.
- Provisioner: workspace provisioning and lifecycle for both backends.
- Web: the 云 IDE panel, the launch route, the start-branch picker that
listed IDE branches, and the workspace count on usage.
- apps/ide, infra/oct, dev:ide and the CI job; IDE parts of local k3s,
network policies, RBAC, docs and the architecture diagram.
A wish can still start from a pushed branch through the API (sourceBranch).
Plan files and stored entitlements may still carry maxWorkspaces; it is
accepted and ignored.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The run page mixed English stage events and agent summaries into the
Chinese console. Messages are now written in Simplified Chinese at their
source (control plane, dispatcher, worker, POC build), keeping commands,
SHAs, branches and error codes verbatim; raw runtime errors get a Chinese
prefix. The agent prompt asks for the plan, summary and questions in
Chinese. File-change parsing accepts old and new messages, and the event
label table covers every event kind written.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Lessons become skills with a category (workflow / pitfall / convention):
one model, one prompt section, one permission rule. A repaired failure
records or updates a pitfall skill deduplicated by failure signature;
harvest sees every skill and may merge into an existing one; corroborated
skills auto-activate per project (skillAutoActivation, default on).
Runs given a skill are counted (skill_usage); platform-maintained skills
retire after 3 failing runs in a row or 90 days unused. Skills can be
imported from SKILL.md / zip, copied between projects and searched across
projects. Migration 004 converts existing lesson rows to skills.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Owners pick from deepseek-flash and deepseek-pro instead of typing names.
A wish uses flash when the project offers it, even if pro was listed first.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
- Skills: per-project know-how the platform proposes from each succeeded
run (in the background, or on request from a run), people confirm,
edit, disable, delete or write; active ones enter later prompts
- Export one skill as SKILL.md, or all as a zip with a directory per
skill, as .claude/skills/ expects
- A wish's report: every run, its stage timeline, the agent's plan,
replies, commands, changed files and model usage, the change, the
checks, failures, reviews and releases, and the full event log, as
Markdown, or laid out for printing to PDF
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- countedTokens: input, output and cache creation in full, cache reads a
tenth, as they cost; the worker meters Claude CLI usage with it and the
usage event says how much counted
- A run's token budget may be raised to 10,000,000
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Projects list the models their wishes may run with, the first by
default; owners and admins set them in the project settings
- A wish may choose one of its project's models; the choice is checked
and pinned to the run, which shows it, and the executor starts the
agent with it (--model), else with the agent configuration's
- Model names may be spelled as the model gateway does
(deepseek-pro@latest[1m]), in projects and agent configurations alike
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Provide six account types and custom combinations of wish, code review,
release and management permissions, applied on each authenticated request.
- Enforce frontend-only accounts when submitting, answering, widening and
reverting wishes; require every contributor to have full access before
skipping backend code review.
- Gate code review and release decisions by their specific permissions.
- Rework member management to create and edit account types, permissions and
project access, and reflect those permissions throughout the console.
- Update the manual and architecture docs with permission tests and
end-to-end coverage.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
When the agent of a frontend-only wish asks to change backend code, or keeps
changing it until the repair rounds run out, the run details offer "改为前端和
后端并继续". It answers the wish with allowBackend: the run may change backend
code from the new requirement revision on, the agent reads that the scope
changed, and the timeline records who widened it. Whether a backend change needs
a review still depends on the submitter's backend permission. Only an answer to
a frontend-only wish accepts the flag.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Each wish says whether it may change backend code. A frontend-only wish is told
which paths it must leave alone; a change to them goes back before any check runs,
the platform puts those files back before the repair round, and the control plane
never integrates them. A wish that may change backend code integrates directly for
people with backend permission and waits for a code review otherwise.
- Owners and admins grant backend permission per person on the members page as well
as per project in the project settings.
- AI optimization has its own button for the wish and for the criteria. It writes a
wish of at most three lines (goal, scope, limits), keeps the details in checkable
criteria, and asks only what the person must decide, as choices whose answers join
the wish; suggested criteria are taken one by one.
- Lists, run titles, Feishu cards and pull request titles show a wish's first line;
the run details show the rest.
- Changed paths no longer follow renames, so moving backend code into a frontend
directory counts at both places for code review and for the frontend-only scope.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
What the pilot asked for, from its meeting:
- Code review: a project names the paths changes to which a person reviews
before they reach the target branch (globs, with exceptions). After the
checks pass, the verifier asks the control plane, and the run waits at
integration until an owner or admin approves the exact commit; approving
integrates it without repeating the checks, rejecting hands the comment to
the agent as a new requirement. Continuing cannot get around it: the
verifier asks again before every integration.
- Undo: "take back this change" starts a run that reverses what a run
integrated on the current target branch, three-way, keeping later commits;
only lines later commits changed too go to the agent. It then verifies,
integrates and delivers like any run. Releases get a rollback button for the
version live in their environment.
- Wish optimization: the local Claude account rewrites a draft wish and its
acceptance criteria by built-in and project rules, with no tools at all;
the person compares and decides, nothing is submitted for them.
- Release confirmation: an environment can make every release wait for a
person, not only those the risk rules flag.
- Feishu notifications: a group bot is told of releases awaiting approval and
changes awaiting review (mentioning the decision makers), runs that need a
person, finished runs and failed releases; each once, signed when a secret
is set, with text from runs never acting as card markup.
- Reviewers see the agent's change summary and who submitted the wish, and
whether the checks ran in the macOS sandbox; the wish form offers only the
executors this deployment can run.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When a run's change passed its checks but failed one once merged onto
a target branch that moved meanwhile, the agent got a repair round for
it, even when the failure came from commits other people had pushed:
it would change their code, and spend rounds and tokens doing so.
The verifier now runs that check, recording no evidence, on the target
branch alone. If the branch passes, combining the two caused the
failure, and the agent repairs it as before. If the branch fails too
while the commit the run started from passes, the commits pushed since
broke the branch: the run waits on the new reason target_broken, uses
no repair round, and has its own verified change as its checkpoint
again. A run that started from a commit already failing the check may
be its fix, and is repaired as before.
Continuing merges the verified change onto the repaired branch and
checks the merge. An integration that continues reuses the change's own
verification under the same policy instead of repeating the checks.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Since the Git config of an agent workspace is reduced to an allowlist
before each checkpoint, every checkpoint read `<workspace>/.git/config`.
A merge candidate is a worktree of the integration cache, whose `.git`
is a file, so the read failed with ENOTDIR: whenever the target branch
moved while a run was working, its integration stopped on an
infrastructure wait, and continuing failed the same way. No test merged
onto a moved target without a conflict.
A GitWorkspace now remembers the worktrees it added from a repository
WishForge owns and leaves their config alone; no agent can reach it. A
workspace whose `.git` someone else turned into a pointer file is still
refused rather than followed. Tests merge onto a target that moved
meanwhile, end to end and at the Git contract.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A release's risk only counted what the target branch gained when the
run integrated. Commits people pushed to the branch directly, and
integrations that were never deployed, went out with the next release
without being classified: an environment preauthorized for automatic
release took a migration or a Dockerfile change pushed straight to the
branch without approval. The POC chose what to rebuild from the same
narrow diff, so worker and coordinator kept running old code; on the
local POC, WishForge had in fact only ever rebuilt the api.
The control plane now gives the verifier the commit of the release the
environment runs, and the classification covers everything between it
and the release, as well as what the integration brought. On the POC,
each deployment records the commit and the image a release put there.
The build plans from that snapshot, the one the release is checked
against: worker and coordinator keep their images only while what they
run differs from the source in web files alone. A component of unknown
source (never deployed by a release, restored by a rollback, or set by
hand, which leaves the annotations stale) is rebuilt, and the release
is marked partial: it needs approval and does not roll back on its own.
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>
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>
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>
An attempt that stopped before its agent started (a failed
installation, an unavailable sandbox, a pause) kept its whole clone and
a recovery note on disk, a new one on every continue, although nothing
in it was worth recovering. Only an attempt whose agent ran and whose
checkpoint was not saved now keeps its workspace.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- verifyRun returned deliver() unawaited inside try/finally, so the
session closed and deleted the workspace while the build still used
it: a build continued after an infrastructure failure always failed.
The failure handlers there were unawaited too.
- The resumed build classified the release risk from the checkpoint's
base, not the target branch it integrated onto, and replaced the
earlier classification: a migration brought by an IDE branch no
longer counted. Integration evidence now records the target commit
it integrated onto, the resumed build classifies from it, and a
commit's classification only ever widens.
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>
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>
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.
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>
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>
The base manifests described a design the code does not have: a Role that only
allowed Jobs, an unused sandbox account, a tool gateway that does not exist and
a deployer bound into the sandbox namespace. They now grant exactly what the
provisioner applies and deletes for runs and IDE workspaces, let sandbox pods
reach the API, Temporal and Git through the control namespace's default deny,
and let the IDE gateway reach workspace pods.
- The API reads the runtime image from WF_RUN_WORKER_IMAGE only, the same name
the provisioner uses; the WF_RUN_IMAGE alias is gone.
- The provisioner takes the public gateway origin from WF_IDE_PUBLIC_URL, which
is what the gateway and API call it, and refuses to start without an explicit
WF_DEPLOYMENT_MODE.
- Environments no longer accept a runnerId that was always rejected.
- The Compose acceptance script uses the current Docker context unless
WF_DOCKER_CONTEXT names one, instead of a hardcoded colima.
- Tests cover waiting reasons and their exits, and the production rejection of
unsandboxed or unstated verification isolation.
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>
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>