v0.8.1

Patch release. Closes the known gap named in the v0.8.0 release body.

claude_code agents spawn with the operator's environment

agent_cc was the only one of the four spawn sites that launched without
utils.operator_env(). ADWs run under uv run, which prepends its ephemeral
dependency venv to PATH and sets VIRTUAL_ENV, so a Claude agent's Bash resolved
python3, pip, and every globally installed CLI through a throwaway build venv
instead of the operator's own toolchain. quality._run, agent_pi, and
agent_cursor have always passed it.

v0.8.0 sharpened this rather than easing it: every agent's system prompt now names
the verify gate's own argv, so a claude_code agent was actively pointed at commands
it resolved differently from the gate. Under the ensemble that put pr_reviewer_2 on
a different interpreter from reviewers 1 and 3 and from the gate itself.

The wrinkle. The Claude Agent SDK merges options.env over os.environ rather
than replacing it, and a merge cannot express a delete. Passing operator_env()
directly would correct PATH but silently restore the popped VIRTUAL_ENV, a
half-applied state no other backend produces. New utils.operator_env_overrides()
re-adds every key operator_env() dropped as an explicit blank, derived from the
diff against os.environ so it stays correct if operator_env() ever drops another
key.

Verified live, not just in tests: a real claude_code scout run reports
python3 at /opt/homebrew/bin/python3 with VIRTUAL_ENV empty, where the ADW
process itself carries ~/.cache/uv/builds-v0/.tmpXXXX. Pinned by four new tests in
engine/adws/tests/test_agent_cc.py, each of which fails if the fix is reverted.

agent_cc.py is MANAGED, so stamped repos pick this up on their next update with
no re-stamp.

Full changelog: v0.8.0...v0.8.1

v0.8.0 - Check commands and check evidence

Every agent is handed the project's check commands. sssf.config.yaml's quality: block was known only to quality.py, so an agent asked to settle a claim with a check guessed an entrypoint - and in a project that wraps its toolchain (a container, a version manager, a task runner) the guess fails for reasons unrelated to the code. agents.project_checks_notice now renders the block into every agent's system prompt as a # Project checks section: each check's name and its real argv, the same entrypoints the verify gate runs. Unconditional, so no ADW, roster, or prompt change is needed in any stamped repo; a repo with no quality: block renders no section.

A review verdict says what evidence it rests on. ReviewOutput gains checks_executed and checks_note. In an ensemble, a reviewer whose checks could not run rests on strictly less evidence than one whose did, and nothing in the envelope said so - a blind reviewer's blocker carried a peer's weight for three rounds. The synthesizer now weighs a reviewer that ran a check above one that did not on any claim about behavior. gates.verdict_consistent refuses a checks_executed: true that names nothing, so a claim of evidence cannot buy authority it did not earn.

Reviewers stay inside their remit: the suite is the verify phase's job, a reviewer may run one check to settle a specific claim, and nothing re-runs the suite - three fan-out branches racing one working tree is how checks corrupt each other.

agents.py, the reviewer/synthesizer prompts, and the operator skill are MANAGED, so stamped repos pick this up on their next update.

PR #44.

v0.7.1 - Execution root notice

Fix: a sandboxed run is spawned with cwd=<worktree>, but agents did their recon in the main repo. The only absolute path an agent held was context_handoff_dir, which anchors at the trace root (the shared main repo) so the trace lands in the shared sssf.db. Nothing told the agent where its code root was, so it generalised from the handoff path and planned against the wrong branch. cwd does not help: an agent that writes an absolute path never consults it.

agents._run_instance now appends an # Execution root block, rendered off run.repo_root, to every agent's system prompt - after the project guidance. Unconditional, so it covers every agent, every ADW and all three backends (claude_code, pi, cursor) with no prompt-template change. context_handoff_dir is carved out by name so read-only agents (writes: []) keep using it verbatim as their write target.

agents.py and the two operator-skill docs are MANAGED, so stamped repos pick this up on their next update - no re-stamp needed.

PR #43.

v0.7.0 — Agent-agnostic skill stamping

The Atelier operator skill is now discoverable by Claude Code, Codex, and PI — not just Claude Code — and stays out of the ADW coding agents the engine spawns.

Highlights

• Canonical .agents/skills/ — the stamp materializes the operator skill at the vendor-neutral .agents/skills/atelier/ (read natively by Codex) and symlinks each skill entry into .claude/skills/<skill> and .pi/skills/<skill>. Per-entry, so the links sit alongside whatever skills a target already keeps there, link only entries that exist (no dangling links), and never clobber a name already taken.
• update.py migration + self-heal — repos stamped before this release (skill at .claude/skills) migrate automatically: old files removed, empty dirs pruned, per-entry symlinks re-established.
• pi isolation — agent_pi.py now passes --no-skills, so ADW pi coding agents no longer inhale the stamped operator skill (or the operator's personal ~/.pi/agent/skills), matching the isolation agent_cc.py already had via setting_sources: [].

Validation

• just test green: 192 engine pytest + 76 cockpit vitest + both seam-parity checks.
• Live smoke with the real CLIs: codex and pi both discover the stamped atelier; install + update/migration verified end-to-end (including coexistence with a target's own .claude/skills); pi isolation confirmed via A/B (without --no-skills pi pulls in 20+ ambient user skills, with it, none).

Full PR: #42

v0.6.0 - Parallel ensemble review

Run N independent review agents concurrently, then a synthesizer consolidates their verdicts.

• Engine: a thread-safe tracer + a new Run.fan_out() primitive (N agent phases in parallel OS threads; branch failures are results, not teardowns; branch phases are non-gating so one failed reviewer never fails the run).
• ADWs: adw_ensemble_review.py (review-only) and adw_build_ensemble_review.py (build -> fan-out review -> synthesize -> bounded revise), sharing adw_modules/ensemble.py. Roster gains pr_reviewer_1/2/3 (diversified models) + synthesizer.
• Cockpit: the waterfall now renders concurrent phases as concurrent (per-lane layout in lib/waterfall.ts) instead of a staircase.

Zero seam-contract change. 179 engine pytest + 76 cockpit vitest + parity green. Shipped via #41.

v0.5.0 — cursor coding-agent backend

Adds a third coding-agent backend, cursor, alongside pi and claude_code. It drives Cursor's models through the cursor-agent CLI (cursor-agent login — no API key), proxying Anthropic/OpenAI/Grok/Kimi/Composer under one subscription, behind the same run(...) -> PiResult seam.

Highlights

• coding_agent: cursor with the cursor/ model namespace (cursor/auto, cursor/claude-opus-4-8-thinking-high).
• Own subprocess + tailed NDJSON like pi; tool events re-emitted in pi's shape like agent_cc. agents.execute() is unchanged.
• System prompt carried in the prompt (no --system-prompt flag), composed only on the first send; resumed correction sends carry bare task text.
• anthropic/* still always routes to claude_code, even over an explicit coding_agent: cursor.

Bounded degradations (documented)

• No dollar cost — Cursor bills by subscription; cost is always $0 (tokens exact).
• Inert context-window valve — usage is terminal-only, so a cursor builder relies on the cooperative handoff; execute() notes this at any cursor build phase.

Quality

Validated end-to-end (scout + builder ADWs). Hardened after a high-effort code review (stderr pipe-deadlock fix, system-prompt re-embed fix, dispatch + resume unit tests). just test green: engine pytest 168 · cockpit vitest 72 · roster-mirror + schema parity · typecheck.

Default roster unchanged — sssf.config.yaml ships a commented cursor exemplar only.

PR #40.

v0.4.0 - chained builder

Chained builder (context-window handoff)

A builder that fills its model's context window on a large task no longer restarts. It hands off and a fresh instance of the same model continues, with the prior work already on disk - unbounded context for one build, not a fallback to a bigger model.

• Cooperative - the builder stops at a clean point, sets continuation: "needs_continuation" and writes a handoff doc.
• Safety valve - the engine hard-kills the run at occupancy_threshold (default 0.8) of the model's context window and synthesizes a handoff from git diff.

Bounded at max_instances (default 3), then the phase fails loudly. Scoped to BuildOutput phases, so every build-bearing ADW inherits it with zero ADW changes. Enabled by default; tuned via the new continuation: config block. max_instances: 1 turns it off.

Verified with 149 engine pytest + 72 cockpit vitest + parity gates, plus live cooperative and valve runs against a real model. Full detail in PR #39.

v0.3.0

Improvements to the Phase-5 sandbox feature, validated end-to-end against a real Dockerized Laravel/Sail/PostgreSQL app (full L1 to L4 ladder, including live per-sandbox PostgreSQL).

Features

• Configurable worktrees namespace (sandbox.project_name). Optional override for the ~/.atelier/worktrees/<name>/ namespace; when unset, derived from the repo's git common dir so a bare-repo/worktree layout no longer collides on a working tree named master/main. New git_helper.git_common_dir().
• Explicit branch override on the sandbox create form. An optional branch input (with inline validation) that wins over the auto-namer, for branch conventions the namer can't produce (e.g. uppercase ticket keys).

Fixes

• Roster prompt paths anchored at trace_root() for sandbox runs. A sandbox run's cwd is the worktree (which need not contain adws/); prompt files now resolve against the trace root like the db/data_dir sink, so runs no longer fail config validation before tracing. Non-sandbox runs unchanged.

Gates green (pnpm typecheck + pnpm check:contract; no db/seam change). cockpit/package.json bumped to 0.3.0.

Full details: #26

v0.2.0

Highlights

Phase 5 - isolated, persistent worktree sandboxes. Each unit of work can run in its own git worktree on a named branch, with per-sandbox deps, ports, backing services, and env, hosting one or more runs until explicit shutdown. Landing (PR / merge / manual) is a per-project workflow. The determinism spine is intact: the cockpit only writes intent (a sandboxes row / a flag); the worker provisions and disposes.

What's new since v0.1.0

• feat(sandbox): isolated, persistent worktree sandboxes - L1 lifecycle, L2 provisioning (deps/ports/env), L3 backing-service hooks, L4 landing workflows (#22)
• feat(sandbox): create-and-run launcher from the Conductor + human-readable branch names via a cheap namer (#23)
• docs: adopt a no-em-dash writing convention in AGENTS.md (#24)
• docs: record the sandbox verification plan as validated on real hardware via the lunacomet.com dogfood - L1/L2/L4 PASS; L3 real backing-services and supervised mode remain open (needs Docker + a project with a local DB) (#24)
• chore(release): bump cockpit to 0.2.0 (#25)

Gates

typecheck + check:contract green (all 10 seam tables incl. sandboxes). Seam contract unchanged.

v0.1.0

First public release of Atelier — a software factory where agents propose and deterministic code disposes.

A Python ADW (AI Developer Workflow) engine runs coding agents inside bounded phases and decides sequencing + acceptance; a Next.js cockpit observes and controls it. Both halves meet at one SQLite file — the engine writes the live trace, the cockpit reads it back. That seam is the single source of truth.

What's in this release

• Engine — ADW scripts composing engineer/agent/code phases, typed envelopes parsed against Pydantic models, and deterministic gates that accept or reject agent output.
• Two coding-agent backends behind one abstraction — claude_code (via the Claude Agent SDK, using the local claude CLI login) and pi (non-Anthropic models). Anthropic is always routed through the SDK.
• Cockpit — a read-only, Zod-validated view over sssf.db with live rowid-cursor tailing (SSE), plus a deliberately tiny write path: a control plane that only enqueues/cancels runs, and surgical roster editing of sssf.config.yaml.
• Determinism spine — the cockpit never spawns a process; a UI-launched run is byte-for-byte identical to a CLI one.
• Distribution — stamp the engine into any repo and keep it updated; an operator skill for driving the factory.

Built phase-by-phase from the roadmap in docs/atelier-plan.html: Phases 0–4 plus Phase 5 slice 1 (SSE live tail).

Getting started

See the README and the guides in docs/. Licensed under MIT.