ADD 3.0.0 — Direction · Build · Verify

ADD 3.0 is a method for building software with AI agents without losing track of what's true — and this release's whole design fits in one sentence: rules written as prose get routed around; rules enforced by the engine hold.

The engine is a NO-EXEC notary over plain markdown in .add/: you approve a direction once (the freeze, cryptographically sealed), the agent builds to green, a receipt records a real test run (exit code, passing test IDs, content hashes of every in-scope file), and a gate refuses a PASS that is unbriefed, unbound, stale, tampered-with, or security-sensitive without a human on record.

Measured, on the record (n=3, single-engine campaign, committed in-repo): 5 of 7 planted ambiguities handled safely in every rep, requirement coverage 1.0, regressions 0, $3.00 mean per run — and the two stable misses are published too. The claim is auditability, not correctness.

📖 Launch post: https://pilotspace.github.io/ADD/announcements/introducing-add-30/
🧾 The adversarial audit (we tried to cheat it): https://pilotspace.github.io/ADD/announcements/2026-08-11-we-tried-to-cheat-our-own-dev-method/

Try it in ten minutes

npx @pilotspace/add init        # or: pip install pilotspace-add && pilotspace-add init

Then open Claude Code, type /add, and describe a feature. Coming from 2.x: add upgrade archives your old bundle whole — nothing deleted.

Full changelog: add-method/CHANGELOG.md

ADD 2.1.0 — two-agent roster maturity + persona-author v11 + flexible TDD + round-visible runs

Minor: the two-agent roster matures and the persona author learns from real
corpora; TDD flexes for non-coding tasks; every honest verify→build round
becomes engine-visible; the dogfood foundation completes its 2.0 migration.

• two-agent roster — add retires; add-worker runs every EXECUTION
  beat (direction · build · verify · persona) and add-advisor is the
  second mind serving EVERY beat (propose-plan · advise-midflight · refute)
  with a per-beat calibration map. The worker gains a mid-flight support
  fan-out for medium/large builds: non-overlapping §3-Scope slices,
  worktree isolation per support worker, the lead serializes git and re-runs
  the FULL suite on every return; the quality floor multiplies, never dilutes.
• persona-author skill — the static .add/personas/_template.md retires
  for a persona-author skill (contract · patterns · seeding references +
  two worked examples). Patterns grow 9 → 11 from a deep diagnosis of 13
  sample subagents and the 256-file teacher corpus: NEW numbers-you'd-defend
  (a named budget beats an adjective; fake precision is worse than none) and
  per-flow stance (what a lens LEADS with at build vs REFUSES at verify —
  the verify stance carries a default NEEDS-WORK verdict); seeding gains
  mine-the-gold / refuse-the-rot source guidance. All 6 live roster personas
  folded to patterns-v11.
• flexible TDD — §4 supports failing-first acceptance checks for
  non-coding kinds (docs · release · infra): verifiable pass/fail evidence,
  red before the artifact exists, green after — the red→green discipline
  holds; only the must-be-executable-code requirement is lifted. Guide,
  template, and book reframe; NO engine change (the kernel was already
  tolerant); 21 non-coding prose-guard tests retired dogfooding the policy.
• round-visible runs — every verify→build return trip is a recorded
  round: add.py phase build [--note "finding"] and every non-exhausted
  heal return increment an uncapped, observational tasks[slug].rounds
  (count + timestamped history, notes verbatim); status names round N;
  the route trace carries "rounds" beside "heals". Heal stays the
  cheat-classed, capped subset; rounds are the honest whole. --note off
  the build target refuses (phase_note_build_only).
• foundation-split — the dogfood board completes the 1.x→2.0 foundation
  migration this package's own migrate verb leaves to judgment: PROJECT.md
  322 → 63 lines (engine-read lines byte-identical), the pre-2.0 standing
  picture folded into the five .add/specs/ living specs with a per-bullet
  fold ledger — the worked example external 2.0 upgraders can follow.
• SKILL.md command cookbook — the skill router carries the common
  call recipes so agents skip the -h round-trip; README copy tightened
  (benefit-led highlights, honest tradeoffs, no dollar figures).

Retired (no CLI/install surface change): the add roster agent (superseded
by add-worker + add-advisor) and the static persona template (superseded by
the persona-author skill; init now creates an empty personas dir and the
hints point at the skill).

ADD 1.17.0 — method-ergonomics + persona domain-fit + dynamic teacher-grade personas + self-improving loop

[1.17.0] — 2026-07-06

Four milestones plus 12 loose tasks: method ergonomics, persona domain-fit,
dynamic teacher-grade personas, and the self-improving observe loop.

Added (method-ergonomics — engine-presented forms replace recalled ceremony)

• Gate ceremony (PLAN/APPROVE banners, SHAPE blocks, decision prompts) is now
  engine-presented at the moment it's needed instead of relying on the AI
  to recall and re-render it from memory — closing the gap where gates were
  silently skipped under load.

Added (persona domain-fit — nudge once a real persona exists)

• The domain-fit nudge now fires once a real project persona already
  exists, instead of repeatedly prompting to seed one; Glossary deltas fold
  into GLOSSARY.md via add.py fold.

Added (dynamic teacher-grade personas — routed by flow)

• Personas are now routed by flow across three agent trees (including
  _bundled/agents), selecting the best-fit existing persona or drafting a
  new one when none fits, with load-performance validated for the schema.

Added (the self-improving loop — observe across 5 domains)

• The OBSERVE phase now folds lessons back into the method across all 5
  domains (Anti-patterns · Abilities · status/compaction cues ·
  self-improve.md map · release notes), so the method keeps improving itself
  from real usage instead of drifting stale.

Fixed

• Ported the reclaim-lock heartbeat fix to the npm/JS twin (parity with the
  Python engine).
• Normalized grep -cl output across BSD/GNU flavors, excluded BSD grep's
  zero-count match line, and protected inline backtick-quoted literal
  comments from being mistaken for stale content during parsing.
• Captured wrapped multi-line ADR harvest fields correctly.

---

Published to npm (@pilotspace/add) and PyPI (pilotspace-add); this
release backfills the missing GitHub Release entry for the v1.17.0 tag.

ADD 1.16 — install-update-hardening + reclaim-lock hotfix + persona domain-fit seed

[1.16.1] — 2026-07-04

Hotfix on top of 1.16.0, plus the first slice of persona domain-fit.

Fixed

• Reclaim-lock race — closed with a holder-side heartbeat, so a stale
  global-install lock can no longer be reclaimed out from under a still-live
  holder; CI reclaim-race test thresholds widened to stop false flakes on
  slower scheduling.

Added

• Persona schema now recommends a flow + abilities on every persona,
  and the persona-seed nudge is project-scoped across status / check /
  new-milestone instead of firing globally.

[1.16.0] — 2026-07-03

Install/update hardening — atomic + concurrency-safe writes (16 carried
lessons, 0 key decisions).

Added

• Atomic, concurrency-safe installer writes. Global-install and
  update --global now use lock-guarded, atomic file operations so two
  concurrent installs/updates can no longer corrupt shared global state.
• Closed out the apple-container audit gaps and the delta-backlog triage
  left over from 1.15.0, and made the report-template ceremony imperative
  at all 4 human gates (PLAN/APPROVE banners render every time, not just
  when the AI remembers to).

---

Both versions were published to npm (@pilotspace/add) and PyPI
(pilotspace-add) at the time; this release backfills the missing
GitHub Release entries for the v1.16.0 and v1.16.1 tags.

ADD 1.15.0 — context-search + seams + artifact-graph + traceability-ids + persona-teacher-bundle + persona-learning-loop + advisor-gated-autonomy + portable-roster + loop-readability

[1.15.0] — 2026-07-02

Ten milestones — the largest bundle yet — round out ADD's self-knowledge
(context-search, seams, artifact-graph, traceability-ids,
ground-trust, drift-guard), extend it past static rules
(persona-teacher-bundle, persona-learning-loop, advisor-gated-autonomy),
and past Claude Code itself (portable-roster). All additive; nothing removed
or renamed on the CLI surface.

Added (context-search — find prior work before you drift into it)

• add.py search <keyword...> — case-insensitive substring search over the
  milestone/task corpus (active + archived), title/goal/rationale lines only, never
  the full body. Surfaced at new-scope drafting and inside the specify/scenarios
  phase guides, so related prior work is found before drafting — not after a
  conflicting design ships.

Added (seams — one home for a shared contract)

• SEAMS.md. Symbols that ≥2 tasks touch get promoted into a milestone-level
  doc that §0 references, so a shared contract has one home instead of being
  re-derived — and drifting — per task.

Added (artifact-graph — a traversable cross-artifact graph)

• Bidirectional backlinks. Every ADD artifact now carries minimal backlink
  metadata (task↔milestone↔release↔deps↔delta) so the cross-artifact graph is
  traversable without re-deriving it by hand.

Added (traceability-ids — every rule earns a stable ID)

• M# / R# rule IDs. Every §1 Must/Reject rule gets a stable ID that §2
  scenarios and §4 tests reference via a covers: line, plus lint coverage so no
  rule ships unscenarioed or untested.

Added (persona-teacher-bundle — a vendored, pinned teacher corpus)

• agency-agents, vendored. The agency-agents teacher corpus ships as a pinned,
  MIT-attributed local library (.add/personas-teacher/), bundled into both the
  npm and PyPI distributions, de-branded from method prose, and refreshed on a
  schedule. The engine stays NO-EXEC; the release build is zero-network.

Added (persona-learning-loop — personas that learn your project)

• Project-fit personas. The AI seeds requirements personas at setup (a living
  doc the project uses live), grows them through the observe→fold self-improve
  loop, applies them at UDD/advisor/build, and exposes a cross-runner
  (Claude Code · Codex · …) persona-aware subagent prompt.

Added (advisor-gated-autonomy — earn autonomy through instrumentation, not by removing the gate)

• A persisted, advisor-guarded auto + parallel run mode so high-speed builds stay safe
  without a human on every step. The whole milestone was dogfooded — every task built
  conservative / human-gated, because you cannot auto-gate the feature that relaxes auto-gating.
• sensitivity: taxonomy. A human-declared TASK-header risk-CLASS (base
  security · data · architecture · mechanical, project-extensible via GLOSSARY.md) — ADD now
  reasons about what kind of risk, not just how much (risk:). Validated at freeze; the engine
  never classifies.
• Persisted run mode + setup choice. The auto + parallel posture is persisted and chosen at
  setup; add.py status shows run mode: parallel + auto. The non-interactive default stays
  byte-identical.
• Persisted DAG-plan snapshot. An auditable snapshot of the computed plan (waves · critical path ·
  tiers) with a freshness check vs the live depends_on edges (edges stay the source of truth).
• Advisor 3-lens verdict. The refute-read becomes a tier-aware single advisor running a sequential
  security → concurrency → architecture sweep recorded in §6 (Verdict · Residue · Binding) — the
  non-functional review is now structured and auditable; advisor_verdict_unrecorded measure-not-block lint.
• Advisor coverage audits (measure, never block). add.py audit flags a missing advisor verdict,
  a self-reviewed verdict (reviewer = author), and a mechanical task with advisor-found residue (mis-tier).
• advisor-gate-relax — the narrowest safe relaxation. A risk: high + sensitivity: mechanical
  task with a recorded Verdict: PASS + Residue: none auto-completes via gate PASS without a lowered
  autonomy level. Security and every non-mechanical class are never relaxed — the human-in-the-loop
  floor is untouched.
• Per-phase spawn hint. status/guide print an advisory subagent-spawn hint (idiom + tier) for the
  active phase; advisory only — the engine still never spawns.
• Documentation, glossary (4 new terms), and headers aligned with the feature.

Added (portable-roster — the phase-roster for every coding tool, not just Claude)

• AGENTS.md / .clinerules carry the roster. Non-Claude coding tools (Cursor,
  Copilot, Codex, Cline, …) now receive the ADD phase-roster's 5 roles and
  boundaries through the AGENTS.md the installer already drops, not just
  Claude Code's native subagents.
• add-advisor — the 5th roster agent. A consultative, frontier-model agent
  (model: opus) any phase can spawn on a medium-hard decision — an ambiguous
  read, a risky shape, a change of approach. It recommends and weighs tradeoffs;
  it never decides.

Changed (ground-trust — GROUND surfaces problems, not just structure)

• GROUND now surfaces the issues/risks it finds in the real code (feeding
  SPECIFY) and links each task's related intent back to the foundation
  (PROJECT.md · GLOSSARY.md · conversation) — specs build on problems found,
  not assumed.

Changed (drift-guard — kill §0 reference rot)

• §0 cites symbols, not line numbers, stamps ground_sha, refreshes at close,
  and strips dead live-phase scaffolding at done — a closed TASK.md stays true to
  the code instead of rotting the moment a line shifts.

Changed (loop-readability — human-scannable output across every phase)

• Report shape, audited and tightened. report-template.md's ARC + 6-block
  shape was checked against its own stated rules (summary-first, one decision,
  guided-choice) across all 8 phase guides' gate-reporting cues; 2 guides
  (0-setup.md's baseline-lock sentence, 3-contract.md's freeze-gate
  sentence) had drifted and were tightened to name SHAPE ahead of the APPROVE
  guided choice.
• SKILL.md's compact pipeline sentence now names the decision banner
  ("rendered first, above everything") ahead of the ARC, matching
  report-template.md's actual render order — closing a gap the shape audit
  surfaced.
• MILESTONE.md.tmpl gains a UI/UX Scope hint — the axes to name
  precisely for a UI feature (information architecture, interaction pattern,
  visual hierarchy, design tokens, component states, accessibility floor,
  responsive breakpoints, user journey), pointing at design.md — with
  adoption pointers wired into 1-specify.md and scope.md so drafters
  actually reach it. The seed this milestone was created to dogfood.

Added / Changed (loose tasks since 1.14.0)

• Report template PLAN/SHAPE + APPROVE banner (report-plan-approve) — the
  chat-report decision point renders a clearer guided-choice banner.
• status pagination (status-pagination) — milestones/tasks sort by
  updated-descending and cap to the top 10, with a --all escape hatch, so a
  long-lived project's status stays scannable.
• Lean 3-agent phase roster + adaptive persona agent (phase-agents-lean).
• Skill-tree compaction (skill-tree-compaction-audit) — audited and
  compacted the ADD skill tree for genuine prose redundancy under the pinned
  lean-fence budget.
• Vendor-tree .gitignore fixes — nested .add/.gitignore vendor-tree
  patterns now resolve relative to .add/, not repo root
  (gitignore-vendor-path-fix); the installer's own .gitignore seed covers all
  3 managed vendor trees (installer-gitignore-mirrors); update --global
  re-seeds .gitignore for every registered project, not just fresh installs
  (update-global-gitignore-seed).
• CI tooling-mirror gap closed (ci-tooling-mirror-gap) — the .add/tooling
  dogfood mirror is materialized in CI's test + publish-guard jobs, not just
  locally.
• Fresh-checkout skip-count tolerance widened
  (nested-suite-skip-count-tolerance) — the nested-suite OK-regex now tolerates
  every known environment-conditional skip, not just the recursion guard.
• Scope-walk hygiene — .claude pruned from the scope walk
  (scope-exclude-claude); stale mirror trees re-synced to canonical
  (mirror-resync); .add/tooling untracked as a regenerable dogfood mirror
  (untrack-add-tooling).

Changed

• Five version sources bump in lockstep to 1.15.0 (package.json,
  package-lock.json ×2, pyproject.toml, .claude-plugin/plugin.json,
  add_method.__version__).

This release bundles 11 closed milestones (seams, context-search,
drift-guard, artifact-graph, ground-trust, traceability-ids,
persona-teacher-bundle, persona-learning-loop, advisor-gated-autonomy,
portable-roster, loop-readability) and 13 loose tasks since 1.14.0. Every
milestone was built end-to-end through ADD's own spec→tests→build→verify flow.
25 open SPEC deltas (non-security backlog spanning the newly-grounded
install-update-hardening tasks, report-shape-scan-audit/skill-banner-cue
follow-ups, and pre-existing items — full list: add.py deltas) ride forward
unresolved into the next cycle.

ADD 1.14.0 — component-polish + installer-polish

Two milestones round out lanes that shipped partially in earlier releases. Installer- and engine-pin-neutral — the ADD engine is byte-identical (ENGINE_MD5 unchanged); all changes live in the installer twins and the component validator. Backward-compatible throughout.

installer-polish — complete the global lane

• init --from-global-data rehydrates a project's user-data from the global home on a fresh clone (the non-destructive inverse of the one-way backup); fill-gaps by default, --force writes a .bak sidecar first.
• prune-data removes home snapshots with no live registry owner — dry-run by default, --force to delete.
• update --global made safe — an O_EXCL home lock serializes concurrent runs cross-twin (a pip-held lock blocks an npm run and vice-versa); every registered path is validated before any write (a relative/traversal entry aborts loud, a non-.add/ dir is dropped).
• Reconcile roll-up — every reconcile reports a file-level N restored · M refreshed summary, so a partially-gutted-but-present managed tree's heal is visible. Pure observation; copy semantics unchanged.

component-polish — close the pillar gaps + harden the edges

• add.py components reader + a components.toml schema-lint (measure-not-block).
• Federation hardening — federate pull path-confines the manifest source to a sibling-repo allowlist with a fail-closed HARD-STOP before any read; a stale producer contract snapshot is surfaced (never red).
• Registry fill + a worked example threading the component flow end-to-end.

Install / upgrade

npx @pilotspace/add@1.14.0 init     # npm
pipx install pilotspace-add==1.14.0  # PyPI

Published to npm (@pilotspace/add) + PyPI (pilotspace-add) via tokenless Trusted Publishing. Full notes: CHANGELOG.

ADD 1.13.0 — self-auditing & honest gates + Trusted Publishing

npm @pilotspace/add@1.13.0 · PyPI pilotspace-add 1.13.0 — both live, npm with OIDC provenance.

Two method milestones + the release-pipeline modernization:

• adr-at-observe — the observe step harvests a ### Decisions (ADR) record at the gate (actor-tagged, from §1/§3/§5/§6), audited at done.
• flow-honesty — every flow gate is now engine-true or honestly disclosed: two structural holes became forceable gates (universal freeze, delta-drain floor); four honor-system edges became disclosures + measure-not-block lints (shallow_deep_check · risk_unset · refute_unrecorded); the earned-green refute-read is a recorded verdict; stale guidance synced to the shipped engine.
• 4 loose tasks — skill-todo-flag, build-strategy-solutions, streams-strategy-pull, strategy-soft-not-hard.
• npm Trusted Publishing (OIDC) — tokenless publish + automatic provenance; this is the first release on it.

Backward-compatible throughout. Suite 2181/0.

Full notes: CHANGELOG.md

ADD 1.12.0 — multi-milestone polish

[1.12.0] — 2026-06-26

Multi-milestone polish release — the intake/roadmap front grows a real queue,
the parallel-front residuals close, and the UDD loop gains a design-intake beat.
Backward-compatible throughout; a single-active project sees no behavior change.

Added (multi-milestone-intake — a request that is several milestones)

• queued milestone status. The milestone status enum becomes
  active · queued · done (was active · done). A milestone can now exist
  non-active, awaiting promotion — created with new-milestone --queued and made
  active with an explicit activate. Migration-safe: an old state with no queued
  milestones reads byte-identically.
• Roadmap intake. intake.md now guides decomposing a request that is several
  milestones into a roadmap that creates all N — 1 active + N−1 queued — instead
  of only the first. Promotion stays human-gated; the whole set is never auto-activated.
• Queued-backlog resume cue. status surfaces the queued backlog (active
  milestone + what's queued next), so a multi-milestone session resumes cleanly. The
  cue is present-only — byte-identical output when nothing is queued.

Added (multi-active-polish — close the parallel-front residuals)

• waves --merge folds the active SET into one cross-milestone DAG and critical
  path (today's waves is per-milestone only).
• mine --all widens the ownership lens past the active milestones — every
  not-done task you own or are assigned, across all milestones plus loose, with an
  email-OR-name match. Plain mine (active-only) stays byte-identical.
• doctor value-domain checks. doctor now flags a bad gate enum
  (∉ {PASS, RISK-ACCEPTED, HARD-STOP}), a bad phase, archived inconsistency, or a
  malformed owner/assignee — beyond the existing referential pointers. It adds
  findings only; it never auto-fails or retro-reds grandfathered history.
• new-milestone add-and-focus. Creating a milestone while one is active now
  preserves the active SET (adds the new one and focuses it) instead of replacing
  the set and evicting the others. --queued and single-active stay byte-identical.

Added (udd-design-intake)

• design-intake beat. The UDD design loop opens with a new front beat that
  interviews the human on four axes — FIDELITY · CONCEPT · LAYOUT · VISUAL DESIGN
  — recorded in DESIGN.md before review-capture-confirm. Convention-only (the engine
  never renders); identity values (brand color/type) stay human-owned — surfaced to
  decide, never auto-picked.

Added / Changed (loose tasks since 1.11.0)

• Descriptive-slug nudge (new-milestone). A milestone slug that is a bare
  version number (v2, v1-1, 1.2 — matched by ^v?\d+([._-]\d+)*$) prints an
  advisory note: suggesting a short descriptive name (e.g. payment-retries) and
  still creates the milestone — never blocks.
• Full-ISO created: stamp. MILESTONE.md's created: line is the full UTC ISO
  timestamp (2026-06-26T03:47:28+00:00); a single _now() instant feeds both the
  rendered file and the state.json record.
• add.py freeze — an engine-stamped human-approval write at the §3 contract
  freeze (DRAFT → FROZEN @ vN with a structured actor line). A security finding remains
  an un-forceable HARD-STOP.
• Queued + await-confirm reminder. A milestone that is both queued and
  --await-confirm now surfaces its milestone-confirm reminder at resume.
• Flow docs. Book ch.02 gains a subsection explaining the milestone-scale
  composition rule — tasks are listed breadth-first up front (the DAG), then each
  specified just-in-time.

This release bundles 3 closed milestones (udd-design-intake,
multi-milestone-intake, multi-active-polish) and the loose tasks above since
1.11.0. Every milestone was built end-to-end through ADD's own
spec→tests→build→verify flow.

ADD 1.11.0 — engine-modularization + audit-hardening

[1.11.0] — 2026-06-26

Engine-modularization + audit-hardening release — the 7k-line monolith becomes a
navigable package, the verify/atomicity/coverage gates get five fixes, and the
standalone (milestone-free) lane becomes first-class. No behavior change to the
CLI, the flow, or any output: this is an internal architecture + hardening release.

Changed

• The engine is now a focused package. add-method/tooling/add.py (7049 → 5640
  lines, −20%) split into 13 add_engine/*.py modules — constants, io_state,
  accessors, predicates, identity, guidelines, render, milestones,
  components, version, release, taskdoc, autonomy — behind a stable
  re-export surface (import add; add.<name> still resolves, public AND _-prefixed,
  so every existing test is untouched). add.py stays the runnable orchestrator
  entry (the load_state/save_state/report_data/cmd_*/main spine). Each of
  the 16 extractions was its own CI-green PR, proven verbatim by an AST source-segment
  diff and gated by the full suite (1815 → 1959 green throughout, no test weakened).
• Two-pin integrity model. Alongside ENGINE_MD5 (md5 of add.py),
  ENGINE_PKG_MD5 is a manifest digest over every add_engine/*.py; both are literal
  pins (never self-hashed) and are checked byte-identical across the 3-tree mirror
  (canonical · .add · _bundled). prepare_bundle + both installers + the .add
  mirror now ship the whole add_engine/ package.

Fixed (audit-hardening)

• Five gate/atomicity/coverage fixes: a phase-build guard, hardened save-state
  atomicity, force-preserve self-healing, setup-tests-before-build ordering, and a
  consumer-stale gate. A security finding remains an un-forceable HARD-STOP.

Added (the standalone / lightweight lane)

• add.py todo — capture a milestone-free backlog item without scaffolding a task.
• loose tasks: release attribution — a release now attributes any done,
  milestone-free task on its RELEASES.md row (not only milestone membership), with a
  separate status cue for releasable loose work.
• fast (task) + auto (mode) flag modes — the standalone lane is first-class:
  a minimal TASK.fast.md, freeze-gated under any milestone, with a flag-mode quick
  reference.

This release bundles 2 closed milestones (audit-hardening,
engine-modularization) and 27 loose tasks since 1.10.0.

v1.10.0 — component-aware major

ADD 1.10.0 — component-aware major. Live on npm (@pilotspace/add@1.10.0) and PyPI (pilotspace-add 1.10.0).

ADD now models every codebase as a graph of components — each owning a source root, its own green-bar, and the contracts it produces or consumes — so one milestone ships a vertical slice across components in a monorepo or across repos. Bundles three closed milestones plus the ccsk --rule-file mode. Every new gate is opt-in or grandfathered: a project that declares no components is byte-identical to 1.9.0.

Added

• Component registry (component-aware-add) — declare parts of a multi-part codebase in .add/components.toml ([component.<name>] = root + green-bar); a task binds with a component: header that anchors its §5 Scope. Declared, never inferred; zero components ⇒ byte-identical to today.
• Per-component verify — a bound task is held to ITS component's green-bar at the gate (component_green_bar_uncited), so two tasks in one milestone can pass on two toolchains. The engine still never runs a suite.
• Cross-component contracts (produces: / consumes:) — [contract.<id>] (producer + consumers); a producer's §3 freeze writes an immutable snapshot at .add/contracts/<id>.json, a consumer pins its hash, a changed re-freeze flags every consumer stale. Missing/malformed ⇒ HARD-STOP.
• One milestone, full-stack slice — a consumes: task is HELD from entering §3 (producer_contract_unfrozen) until its producer freezes, so a BE→FE slice ships in one milestone.
• Multi-repo federation (add.py federate pull <id>) — declare [federation.<id>] (source + optional pin) and pull a byte-for-byte copy of a producer repo's published snapshot. Fail-loud: unknown id / unreadable source / invalid snapshot / version mismatch each HARD-STOPS and lands nothing.
• Component pillar docs — book chapter 17 · Components, a skill guide, and glossary terms.
• The book as a live site (docs-site) — the AIDD book ships to GitHub Pages as a MkDocs-Material site; mkdocs build --strict gates the deploy. Packages stay zero-dependency.
• Rule-file mode for ccsk projects (--rule-file) — relocate CLAUDE.md's block to .claude/rules/add-workflows.md for .ccsk/ projects; CLAUDE-only, idempotent, fail-soft, mirrored across all three installers.

Changed

• Guided dynamic loop (loop-steering) — status and guide now STEER into the build→verify loop rather than only reporting it.

Compatibility

Python 3.11+ is required to use the component pillar (stdlib tomllib); on 3.10 the engine runs unchanged and a declared components.toml fails loud. Published packages remain zero-dependency.

Evidence: suite 1745/0 · check 378/0 · audit clean (74 tasks) · mkdocs build --strict clean. Full notes in CHANGELOG.md.