CAST v4.0.0

Breaking. CAST ships no documentation. The 22-file docs/ payload is gone; in its place, target projects bring their own documentation and a source map points the pipelines at it. The install footprint shrinks to .claude/ (agents, skills, and the new cast/ machinery) plus artifacts/ — nothing CAST-shaped lands in the project's source tree, and CAST no longer owns any part of CLAUDE.md beyond one appended section.

Why this release exists

v3 shipped a full documentation scaffold — PRD, conventions, topic guides, file-placement rules — and /cast-init spent most of its effort mapping a project's existing docs onto CAST's shapes. Real projects already have documentation systems, and forcing them through CAST's made the agent team less portable, not more. v4 inverts the relationship: you state where your documentation, standards, and registers live; the pipelines read them there. Planning distills what applies into each milestone's own artifacts, so plans are complete enough that engineering never reads your docs at all — the agents become highly portable and stop depending on CAST-installed infrastructure.

Added

• The source map — .claude/cast/SOURCES.md. Six categories of user-owned locations (Standards & Conventions, Product & Requirements, Architecture & Design, Testing & Quality, Documentation Home, Project Registers), each a path/glob plus a one-line description. Written by /cast-init from a new source-map interview (discovery finds the candidates; you confirm, correct, or declare a category honestly empty), hand-editable, and verified by /cast-doctor. _None declared._ is a valid answer — the pipelines then plan from code inspection and say so.
• The Standards Digest. A new (required, scales) section of the milestone README: the distilled, source-cited rules that bind this milestone's work, written by Product at Stage 1 from the mapped standards and testing sources. Task Context Manifests now cite milestone artifacts only — the digest is how project standards reach engineering. One-off /agent-task work gets its own digest section in the task file, distilled by Pre-Flight.
• /agent-plan Source resolution. Before Stage 1 the orchestrator resolves the source map to per-category file lists and passes each stage its sources (Product: requirements/standards/testing; Architect: architecture & design; UI: design systems). A new hard rule rides along: plans are self-contained — /agent-code never opens a mapped source, and a digest gap found during engineering is a planning defect routed through the task-amendment rule, never a license to browse.
• A deterministic installer — scripts/install.sh. v4's fixed placement (agents → .claude/agents/, skills → .claude/skills/, machinery and templates → .claude/cast/, scaffold → artifacts/) means no LLM decides where files go: a bundled bash script performs the whole copy — substitution of the install-time tokens, the scaffolding strip (skeletons excepted), the CLAUDE.md section append, never overwriting an existing file (--force to override, --no-ui for the opt-out pair, --dry-run to preview). /cast-init Phase 5 runs it for every Create action and keeps only the judgment work (discovery, the source-map interview, migrations, merges); it also works standalone for a fully script-driven fresh install. It records .claude/cast/install-manifest.txt (per-file hashes plus the substitution values), and --upgrade makes every future upgrade script-only: byte-unmodified CAST files are replaced, new files added, obsolete unmodified ones removed, and the CLAUDE.md CAST section and stamp refreshed — while customized files are kept and reported for /cast-init to merge (the script never overwrites or deletes bytes it did not itself install). The one-time v3→v4 /cast-init migration writes the manifest, making it the last LLM-driven upgrade a project needs. CI runs install, customization retention, and upgrade end-to-end and asserts the results.

Changed

• .claude/cast/ is the new home for CAST's machinery. PIPELINE_LOOP.md and STAGE_CONTRACT.md (formerly docs/) and the ten document templates (formerly top-level templates/) install inside .claude/ with the tooling. The stage contract adds the closed-read-set rule for sources; the docs-queue rule now names the Documentation Home.
• Docs Writer maintains your documentation. It drains the docs queue into the Documentation Home mapped in the source map, matching that documentation's existing structure and style. With no Documentation Home declared it is never launched — pending entries surface to the user at each checkpoint instead.
• /cast-doctor trades the documentation diet for source-map medicine. The v3 two-tier, Inference-Bar-gated pruning function is gone with the docs it pruned. In its place: five source-map checks (entries resolve, tables well-formed, reality drift, writable Documentation Home, staleness) alongside the structural/state catalog and slimmed coverage checks.
• /cast-release reads the changelog location from the source map's Project Registers — with none declared it skips changelog work, says so, and includes the would-be entry in the release record.
• CLAUDE.md is the user's file. root/CLAUDE.md collapses from a full parameterized project template to the single appendable CAST section (workflow summary, source-map pointer, artifacts conventions, version stamp). CAST adds no Memory Imports and never merges into user sections.
• /cast-init is rebuilt around the interview. Discovery 1.3 finds where documentation actually lives instead of mapping it onto CAST docs; dispositions carry the .claude/cast/ install rules and a v3→v4 migration table; execution installs .claude/cast/ and appends the CLAUDE.md section; validation checks the source map resolves. Stale 8/15-agent counts in the references corrected to 7.
• The install-time placeholder set collapses to [PROJECT_NAME], [TEST_CMD], [BUILD_CMD], [MAX_LOOP_COUNT], [VERSIONING_SCHEME], and the auto-stamped [CAST_VERSION] — project context reaches agents through your own CLAUDE.md and the source map, not baked-in tokens. README's placeholder table and validate.yml's token lints regenerate accordingly, and CI gains a v4 layout lint (template references only at .claude/cast/templates/, no CAST docs/ citations, no work instances under the machinery).
• The example fixture demonstrates BYO docs: example/docs/ and the conventions in example/CLAUDE.md are the project's own documentation, example/.claude/cast/SOURCES.md maps them, and the M1 milestone README carries a real Standards Digest with per-rule citations; task manifests cite it instead of CAST docs.

Removed

• The entire docs/ payload (22 files): PRD, CONCEPT, GLOSSARY, DESIGN_RATIONALE, CODE_PATTERNS, FILE_CONVENTIONS, ERROR_HANDLING, TEST_FRAMEWORK, ASSETS, MVP_LAUNCH, ADDITIONAL, CHANGELOG, the four topic docs (FRONTEND/BACKEND/CLI/MOBILE), FIRST_RUN, CLAUDE_CODE_SETTINGS, MODEL_OPTIMIZATION, and docs/README. The two process contracts moved to .claude/cast/; everything else is replaced by the source map pointing at your own material. FIRST_RUN's smoke checklist folded into the /cast-init closing summary; MODEL_OPTIMIZATION's orchestration notes survive in the skills' Model Compatibility sections.
• The top-level templates/ install location (moved under .claude/cast/templates/), and the v3 CLAUDE.md Directory Conventions section and Memory Imports block.

Migration (v3 → v4)

Re-run /cast-init after npx skills update (or /plugin marketplace update). The upgrade plan applies the governing rule — content you wrote is yours and stays exactly where it is; content CAST shipped and nobody filled is clutter:

• Filled docs (a real PRD, populated conventions, a maintained changelog) are preserved in place and proposed as source-map entries; your existing docs/ directory is the natural Documentation Home candidate.
• Unfilled CAST skeletons and the CAST process docs are proposed as Deletes (itemized, requiring your approval; the contracts are reinstalled under .claude/cast/).
• templates/ is git mv'd to .claude/cast/templates/, preserving your customizations.
• Your CLAUDE.md keeps every section you wrote; CAST's v3 Directory Conventions section, its @docs/... imports, and the old stamp are replaced by the one v4 section.
• Documentation moves and deletes execute before SOURCES.md is written, so every map entry points at a post-migration path.

CAST v3.1.0

Individual tracking for user-found bugs, a one-off task backlog, and a planning stage that consumes both.

Added

• /file-bug intake skill (skills/file-bug/). Reviewer files the bugs found inside pipeline runs; until now a bug the user found had no route into the tracker short of starting a pipeline. /file-bug <description> files it the moment it is noticed: one instance of templates/BUG_REPORT.md at artifacts/one-off/bugs/bug-{XXX}-{slug}.md plus an artifacts/BUGS.md index row (Found during: user report — /file-bug, Status New, initial severity from the described impact — never guessing fields the user did not supply). Runs in-session, launches no agents, fixes nothing; Product remains the triage authority.
• /add-task intake skill (skills/add-task/). Queues small, self-contained work as TASK-XXX entries in the new artifacts/TASKS.md backlog without running anything. Screens scope at filing — clearly planning-tier work is routed to /agent-plan instead of queued; borderline entries carry a Notes flag for Pre-Flight to settle. Runs in-session, launches no agents.
• artifacts/TASKS.md — the one-off task backlog, new in the artifacts scaffold (installed by /cast-init alongside BUGS.md). Carries the canonical backlog lifecycle (Open → In Progress → Done, terminal Adopted → M{N} / Dropped) and field-ownership table, an index, and one entry block per queued task. Entries are queue entries, not task files — /agent-task instantiates templates/TASK.md when work starts.
• /agent-task backlog mode. /agent-task TASK-XXX runs one queued entry (its entry block is the task description); /agent-task backlog drains every Open entry sequentially through the full mini pipeline, flagging entries that fail the scope check (Open — needs planning) and continuing rather than halting. Invoked with no argument, /agent-task now offers backlog mode when Open entries exist. The orchestrator advances each queued entry's index row (Open → In Progress → Done, Resolution linking the task file).

Changed

• /agent-plan Stage 1 gains an intake sweep (new step 5, in the same Product launch as the Deferred re-triage): open user-filed bugs (artifacts/BUGS.md rows at New/Triaged) and open backlog entries (artifacts/TASKS.md rows at Open) are reviewed against the milestone being planned, and relevant items are adopted — a bug's fix becomes a task or lands in an existing task's criteria (bug triaged, index mirrored); a backlog entry becomes a milestone task with its row marked Adopted → M{N}. Items not adopted stay untouched: the sweep only adopts, it never closes or drops queue items. The Stage 1 input list now passes both queues; agents/product.md carries the matching duty.
• artifacts/BUGS.md documents /file-bug as the second filing route (user reports, filed under one-off/bugs/) in its lifecycle prose and field-ownership table; templates/BUG_REPORT.md adds the user report — /file-bug Found-during value.
• /cast-init installs the two new skills and the TASKS.md scaffold: roster pipeline-skills mapping, execution 5.5/5.7, dispositions, and validation checks 3/3a updated. The 5.5 install list also now names cast-release explicitly (it was installed but missing from that list).
• Payload READMEs, root README, TROUBLESHOOTING.md decision table, docs/FIRST_RUN.md smoke checks, and both CLAUDE.md files updated for the seven-skill roster and the new backlog file.

CAST v3.0.0

Breaking. The roster goes from 15 agents to 7, the engineering loop from four stages to two, and every agent file is rewritten. A clean task's fixed setup cost drops from ~72,000 tokens (v2.1) to ~10,000.

Why this release exists

A performance audit of v2.2 measured what a stage actually pays before it does any work:

Item	Tokens	Paid
docs/PIPELINE_LOOP.md (every agent's Rules block cited it)	~5,050	every spawn
root CLAUDE.md	~2,130	every spawn
@docs/CODE_PATTERNS.md (unconditional memory import)	~2,070	every spawn
Agent definition	1,300–4,073	every spawn

Two things stood out. The largest single item in every stage's context was the document that existed to keep context small — PIPELINE_LOOP.md had grown to 5K tokens of routing rules, loop counters, and circuit breakers that no stage acts on. And six of the fifteen agents were paying a full cold context to re-derive context another agent already held.

The organising idea of v3: a role earns its own agent when it brings independence — a different reader examining work someone else did, where the risk is self-serving judgment. Reviewer reading Coder's diff is independence and is worth its spawn. A separate agent writing tests for code another agent just wrote is not independence; it is a second pass by an equally-invested party at full cold-context cost. Every merge below is a case of the second kind, and every gate the merged agent enforced is preserved as an evidence requirement.

Changed — the roster: 15 agents → 7

product, architect, ui, ceo, coder, reviewer, docs-writer.

Removed	Merged into	Reasoning
tester	coder	It re-read the same task file and the same diff Coder had just written, in order to test it. The gate survives, stronger: Coder's handoff entry must carry the verbatim tail of the [TEST_CMD] run, and Reviewer rejects the entry unread if it is missing or failing. Paraphrased results ("all green") are a missing block. The red→green proof on defect fixes is unchanged.
refactor	coder	"Behavior-preserving restructuring within the flagged Issue" is Coder's own job on a loop-back. A separate 1,942-token definition plus a spawn to do what Coder does.
debugger	coder	Two cold contexts on one defect, the second re-deriving the first's context. Root-cause investigation is now a step inside Coder's defect pass, required whenever the mechanism is not obvious from the diff — with root cause, affected modules, and the alternatives considered written to the bug file before any code changes.
bug-gatherer	reviewer	It re-read the task to transcribe a finding Reviewer had already written into a template. Its documented five-step workflow ended with "read the report back to the reporter and ask if it is accurate" — impossible for a subagent with no channel to Reviewer. Reviewer holds the finding and writes the bug file.
security + performance	ceo	Two agents reading the same architecture document in the same parallel round, producing two files of the same shape, each ending in one flag line — and then the CEO reading their output in full minutes later. The two lenses stay distinct in the output — that is what mattered; the extra spawns were not. The CEO's risk pass writes the one review at reviews/risk.md (Security section, Performance section, both flag lines) before its cross-cutting review, and runs the flagged implementation review at milestone completion. The independence that earns a spawn is author-vs-reviewer; two reviewers of the same plan share one launch. (A pre-release v3 draft carried the lenses as a standalone risk agent before folding it into ceo.)
validator	product + orchestrator	Its bookkeeping (AGENT_STATE rows, archival) is orchestrator file-writing. The retrospective went to Product. Its conflict-resolution protocol had time-based triggers — "after 7 days blocked", "conflicts older than 14 days", "questions pending more than 2 sessions" — that can never fire in a pipeline where a milestone runs in one or two sessions. Unresolved specialist disagreements now escalate to the user, which is whose decision they were.
release	/cast-release skill	Checklist execution against files the session can already read. An agent spawn to run a checklist is a spawn spent on ceremony. Same gates, now in-session.

Each merge target explains its own history in a comment block, so a reader who wonders where Tester went finds the answer in coder.md.

Changed — the engineering loop: 4 stages → 2

v2:  Coder → Tester → Reviewer → Product        4 spawns (clean task)
v3:  Coder(+test+commit) → Reviewer → [Product?]  2 spawns

docs/PIPELINE_LOOP.md Step 4 renumbered to Step 3 (3a clean close / 3b Product validation — unchanged in behavior from 2.2.0). Coder handles all three return paths in one pass: Fix Now defects, Reviewer Issues, and Product criteria rejections. Findings of different kinds from one review are resolved together, not one round trip each.

Loop-backs are where this compounds: a 2-loop task went from 8–10 spawns to 4–6, and every one reuses the same two agent types, so it hits a warm prompt-cache prefix.

Added — docs/STAGE_CONTRACT.md

The split that fixes the biggest measured cost. ~83 lines carrying the closed read set, the handoff-entry format, and the one-line reply — the only process document an agent reads. PIPELINE_LOOP.md keeps the routing, loop counters, commit discipline, and circuit breakers, and is read by the orchestrating skill only. Both files say so explicitly; the skills are told never to pass the loop doc into a stage. This alone removes ~4,000 tokens from every spawn.

Added — /cast-release

Verifies the gates (milestone closed, tests pass, build succeeds, no blocking bugs — Deferred counts as open — risk flags cleared), derives the semantic version from what actually shipped, updates docs/CHANGELOG.md, and writes a release record with a GO/NO-GO. Does not tag, push, or publish: that stays the user's command.

Fixed — four contradictions the audit surfaced

These were live bugs, not just inefficiency:

1. Every agent was told to violate the read-set rule. All 15 files ended with "Live state lives in artifacts/AGENT_STATE.md → ## <agent>. Read that section on activation" — while the Handoff Protocol said the read set is closed: task file, manifest, "Read next", "Nothing else." Removed. AGENT_STATE.md is now orchestrator-written, no agent reads it, and it shrank from 506 lines of per-agent tables to four tables with no other home (Decisions Log, Milestone Progress, Performance Budget Tracking, Open Questions). The removed tables duplicated state that already had an owner — Current Work is the task file's Status field, the review queue is the Handoff Log, Future Work is the README's out-of-scope list.
2. Coder carried 90 lines of verification scaffolding that CAST's own model policy says to delete. MODEL_OPTIMIZATION.md's Opus 5 profile: "Delete verification scaffolding from custom prompts... it duplicates work the model already does and inflates cost." coder.md then required a Pre-Handoff Checklist with ~40 boxes including "I am confident this implementation matches the specification" and "I have read the relevant architecture document(s) in full" — self-attestation from a model that self-verifies, duplicating Reviewer's checklist. Gone, along with Refactor's 47-line equivalent.
3. Dead human-team process. Validator's day-count escalation ladder and Architect's ASCII Gantt chart of "Coder Sprint A/B/C" with "Architecture must complete a document at least one work session before Coder begins". None of it could ever fire.
4. The unconditional import contradicted the Context Inference Bar. CODE_PATTERNS.md was imported into every session and every subagent while being largely the mechanical restatement — naming, file layout, function ordering — that the same document says Opus 4.8+ and Sonnet 5+ infer from the codebase. The Memory Imports list now ships empty, with guidance on what earns a slot (a non-obvious domain convention, a glossary whose terms appear nowhere in the source) and what does not.

Changed — effort policy retuned for Opus 5

xhigh is opt-in, not a standing default on four roles. On Opus 5 it is the most expensive setting in the family — thinking is on by default and lowering effort does not shorten the response — so a standing xhigh buys reasoning tokens without buying concision back. New defaults: Architect/UI/Risk/CEO/Reviewer high, Coder medium, Product high at planning and low for triage, Docs Writer low. Each agent names the cases that warrant raising it.

Coder at medium is the change most likely to raise an eyebrow. The reasoning: Coder implements against a task file that already carries the design decisions (made by Architect at high), an explicit Files list, and acceptance criteria — the hard thinking happened upstream. The safety net is the loop, not the effort setting: Reviewer runs at high and reads the diff independently. Spending xhigh on the stage that writes code and high on the stage that checks it inverts where the leverage is.

MODEL_OPTIMIZATION.md also now states the ordering explicitly: spawn count dominates both model tier and effort.

Changed — agent files rewritten (~52 lines each of org chart removed)

Purpose / Goals / Authority / Inputs / Outputs averaged 52 lines per agent restating what the Rules block and the task file already carried — documentation about a role, loaded as instruction to it, on every spawn. Replaced with a compact Role, the duties, and a Boundaries list keeping only the binding "may not" constraints. Agent files went from 130–239 lines to 68–157.

Removed — ## Revision History t...

CAST v2.2.0

Pipeline throughput: fewer subagent launches per task and per milestone, with every gate preserved.

A clean task previously cost six cold subagent contexts — Coder, Tester, Reviewer, Product, Docs Writer, Validator. It now costs three, and a small feature's planning run drops from six stages to four. Nothing is removed from the spec: every acceptance criterion is still checked line by line, every docs entry still drains, every task outcome is still recorded, and the CEO verdict still gates engineering. What changed is when and by whom.

Added

• Acceptance Criteria Check (agents/reviewer.md, docs/PIPELINE_LOOP.md → Step 3). On approving a clean version, Reviewer now walks the task file's Acceptance Criteria and appends one line per criterion to its Handoff Log entry — each Met with an evidence pointer (commit, test name, or file:line), Not met, or Product judgment. Met requires evidence a later reader can follow; a criterion Reviewer believes is satisfied but cannot point at is Product judgment, never Met, and the guidance biases toward over-flagging (one extra Product invocation) over under-flagging (a task closed without real validation). Handoff Protocol rule 3 gains this as its second cap exception, and templates/TASK.md carries the block format.
• Step 4a / Step 4b split (docs/PIPELINE_LOOP.md → Step 4, renamed from "Product Validation" to "Validation"). 4a: every criterion Met → the orchestrator writes the Status and progress entry itself, no Product spawn; Reviewer's entry is the validation record. 4b: Product is launched when any criterion is Not met or Product judgment, a criterion was amended mid-task, the task carries a CEO Approval Condition, or the task resolved a filed bug (the Verified → Closed transition is Product-owned, and 4a launches no agent that could make it). /agent-task adds a scope-creep trigger — files touched beyond the task's Files list always route to 4b — and leans toward Product judgment because its criteria come from a free-form description.
• Overflow drain (skills/agent-code/SKILL.md, agents/docs-writer.md, artifacts/STANDUP.md). The task-completion checkpoint counts pending docs entries and invokes Docs Writer mid-milestone only at 10 or more, bounding the queue on a long milestone without paying a drain per task.
• Section Scaling rule on the three heavyweight templates — templates/ARCH_SYSTEM.md (265 lines), templates/MILESTONE_VALIDATION.md (271), templates/UI_SPEC.md (216). Required sections stay present, but sections newly marked (required, scales) collapse to a single N/A — <reason> line when the milestone does not exercise them: Message Flow, State Storage, Integration Points, Performance Budget, and Manual Testing Checklist in ARCH_SYSTEM; Visual Style, Writes/Actions, and Edge Cases in UI_SPEC; Visual/Data/Integration Validation and Regression Testing in MILESTONE_VALIDATION. agents/architect.md, agents/ui.md, and agents/product.md gained matching guidance. Depth scales; coverage does not — the milestone validation record still carries one Task Validation block per task, and UI_SPEC's six interaction states and accessibility section remain non-negotiable.

Changed

• The task-completion checkpoint launches no agents. It writes the task's Status and progress entry, then checks the overflow bound. Docs Writer and Validator are batched to milestone completion: both consume a queue or a state file rather than the task's live context, so running them per task spent two cold subagent contexts on bookkeeping that reads identically when batched. Resumability is unaffected — /agent-code Task Selection resumes from each task file's Status field, not from artifacts/AGENT_STATE.md.
• Validator records the whole milestone in one pass. At the milestone-completion checkpoint it walks every task file (Header and Handoff Log), recording each task's outcome individually plus the milestone outcome, and runs the per-task Process Checklist across all tasks in the same invocation. Batching changes when the rows are written, never how many. An interrupted run is picked up by the next invocation, which sweeps task files with a terminal Status and no recorded row.
• Docs Writer drains a multi-task queue. New guidance to read the whole queue before writing, reconcile entries that supersede each other (a convention introduced in task 2 and renamed in task 5 is one documentation change), write the end state, and mark every drained entry ✅ — including superseded ones, since ✅ means "accounted for", not "written verbatim".
• Product's per-task role is now triggered, not automatic (agents/product.md). When spawned at 4b, Product must dispose of every flagged criterion explicitly and may accept Met criteria on Reviewer's evidence rather than re-deriving them. Product's milestone-grain validation stays unconditional: the validation record covers every task including 4a closures, which is what makes 4a a deferral of Product's per-task review rather than a removal of it — a 4a-closed task whose criteria do not hold is caught there and re-enters the loop. Product also gains guidance to author criteria a Reviewer can settle from a diff and a test run wherever the requirement allows.
• /agent-plan single-task mode is now Light Mode, widened from one task to small features generally. It engages on request (/agent-plan light: <feature>; single: remains accepted as the one-task case) and automatically when Stage 1 scoping finds all five of: 3 tasks or fewer, no new screen set, no security-sensitive scope, no applicable performance budget, and nothing cross-cutting. Any one failing means the full run, the conditions are judged from Stage 1's output rather than the invocation text, and genuinely borderline cases choose full mode. The existing per-task flags (Needs UI Spec, security-sensitive scope, applicable budgets) still pull a skipped stage back in, and the CEO remains the backstop — a plan that clearly needed a skipped stage earns REVISION REQUIRED naming it. Skipped-stage placeholders in templates/CEO_REVIEW.md now read "N/A — light mode, stage not run".
• Roster descriptions synced for reviewer, docs-writer, and validator across their agent frontmatter and references/roster.md. Diagrams, pipeline tables, and prose in README.md, TROUBLESHOOTING.md, agents/README.md, skills/README.md, and docs/README.md updated to match.
• The example/ fixture now shows the new flow. T-5 closes via Step 4a (Reviewer's criteria check, 7/7 Met with evidence, no Product entry); T-1 through T-4 carry criteria checks but still route to Product via 4b for their CEO Approval Conditions, with T-4 demonstrating a Product judgment flag and its disposition. All four docs entries drain in the single milestone-completion pass instead of at four task checkpoints, and the retrospective and STANDUP Entry Grammar were updated to match.

Migration

Existing installs keep working unchanged — the pipelines are Markdown, and an install still running the 2.1.0 files simply pays the old per-task cost. To adopt: re-run /cast-init (it refreshes CAST-owned files and preserves your content), or hand-apply to .claude/. In-flight milestones need no special handling: a milestone planned under 2.1.0 has the same directory layout, and the first /agent-code run under 2.2.0 picks up from each task file's Status field as before. Task files written under 2.1.0 have no Acceptance Criteria Check in their Handoff Logs; those tasks route to Step 4b, which is the pre-2.2.0 behavior.

CAST v2.1.0

Claude Opus 5 becomes the preferred executing model for the roster.

Added

• Claude Opus 5 is the preferred executing model. docs/MODEL_OPTIMIZATION.md adds claude-opus-5 to the ladder as Preferred (Opus 4.8 → Supported), a full Opus 5 behavior profile (self-verifies unprompted — delete verification scaffolding; expands task scope — minimal-change discipline and Files lists are load-bearing; delegates readily — the reverse of 4.7/4.8; longer responses that effort settings don't shorten; same coverage-first review-recall rule), an "Opus 5 additional requirements" block (separate rate-limit bucket from the Opus 4.x pool, thinking on by default with disabled only at effort ≤ high, stop_reason: "refusal" handling, 512-token prompt-cache minimum, fast mode on the Claude API only at its own pricing), and Opus 4.8 → Opus 5 / 4.x → 5 upgrade checklists plus a 5 → 4.8 downgrade note.

Changed

• The three pipeline skills' Model Compatibility sections gain an Opus 5 orchestration note (spawn only named agents, hold tasks to their Files lists, no extra verification passes), and /agent-code's review-recall rule now names all supported models.
• README prerequisites, agents/README.md, skills/README.md, docs index, roster/validation references, docs/FIRST_RUN.md, and the example fixture's author-model lines now name claude-opus-5 as the preferred executing model.

CAST v2.0.1

Post-release fixes for stale v1 paths that survived the 2.0.0 restructure, caught in post-merge review.

Fixed

• Installed artifacts/STANDUP.md (and the example fixture's): the Related Documents table pointed at the v1 milestones/milestone-{N}-{slug}-validation.md path (now milestone-{N}-{slug}/reviews/validation.md) and described BUGS.md as an "active bug tracker" (it is the global index — one line per bug pointing at the per-bug file).
• Installed docs/PRD.md: the Timeline preamble described a milestone as having a single dedicated task file; reworded for the v2 layout — one task file per task under the milestone's tasks/ directory.
• Example fixture artifacts/AGENT_STATE.md: one validation-record reference used the v1 single-file path.

Added

• CI guard for v1 artifact paths: validate.yml now fails on any v1-shaped path (milestones/milestone-*, combined -tasks.md/-validation.md/-completion.md filenames, MILESTONE_TASKS) in the payload or example. The references/ migration tables stay exempt — they legitimately map old paths to new. This check caught the fourth instance above the moment it was written.

CAST v2.0.0

Breaking restructure of how agents hand off work and where artifacts live. Artifacts are now grouped by milestone instead of by type, every task and every bug is its own isolated file, and agent-to-agent handoffs follow a minimal-context protocol: each stage reads only its task file's Context Manifest and appends one capped Handoff Log entry. Existing installs need the migration below.

Changed

• artifacts/ is grouped by milestone. The v1 by-type directories (milestones/, architecture/, ui-specs/, reviews/) are gone. Each milestone owns one directory: artifacts/milestone-{N}-{slug}/ containing README.md (the milestone's highest-order document: definition, Status, Task Index, CEO Approval Conditions), architecture.md, ui.md, supplemental arch-{slug}.md / ui-{slug}.md docs, reviews/{security,performance,ceo,ux,validation,completion,retrospective}.md, tasks/ and bugs/. Cross-milestone state (BUGS.md index, STANDUP.md, AGENT_STATE.md) stays at the artifacts root; /agent-task work lands under artifacts/one-off/. Milestone directories are created by /agent-plan Stage 1 — /cast-init no longer pre-creates by-type subdirectories.
• One file per task. The single -tasks.md breakdown is replaced by tasks/task-{T}-{slug}.md, one instance of the new templates/TASK.md per task — self-contained with description, dependencies, acceptance criteria, a Context Manifest (the complete read set for the task, seeded by Product and extended with section anchors by Architect and UI), and an append-only Handoff Log. Task status lives ONLY in the task file's Header; the milestone README's Task Index deliberately has no status column, ending v1's dual-write bookkeeping. templates/MILESTONE_TASKS.md is renamed/rewritten as templates/TASK.md.
• One file per bug. Bugs are standalone files (templates/BUG_REPORT.md instances) filed beside the work that surfaced them (milestone-{N}-{slug}/bugs/bug-{XXX}-{slug}.md or one-off/bugs/); artifacts/BUGS.md becomes the global index — ID assignment, one status line per bug, lifecycle and field-ownership rules, and the Tester-owned regression checklist.
• Minimal-context Handoff Protocol (new section in docs/PIPELINE_LOOP.md, binding on every agent and both engineering pipelines): the task file is the handoff medium; a stage's read set is closed (its agent definition + the task file + the manifest entries + the latest handoff entry's "Read next" — nothing else); handoff entries are capped fixed-format blocks (Outcome / Files touched / Read next / Open items, max 10 lines, no narrative); findings live in their canonical artifact with only pointers in the entry. The v1 pass-forward rule is superseded. Agent rule blocks, /agent-plan stages (Architect and UI now write manifest section-references per task), /agent-code (stages receive the task file path, Task Selection reads only task Headers), and /agent-task (creates its task file under one-off/) are all rewritten to the protocol. CEO Approval Conditions move from the tasks file to the milestone README, referenced from affected tasks' manifests.
• docs/FILE_CONVENTIONS.md, artifacts/README.md, agent files, payload docs, and both READMEs rewritten to the new layout and naming rules (fixed in-directory filenames; task-{T}-{slug}.md; bug-{XXX}-{slug}.md). Naming is now governed by an explicit two-tier case rule: UPPER_SNAKE for system singletons (docs, templates, the artifacts-root state files), lowercase kebab for instance files that multiply (milestone dirs, task files, bug files, reviews) — identifiers like BUG-001 and T-1 stay uppercase in prose while their files are lowercase.
• CI (validate.yml): the example structural check derives instance→template pairs from the new path patterns (including TASK.md and BUG_REPORT.md contracts), the path-split lint recognizes v2 instance patterns, the completeness check walks milestone directories, agents are checked for a tools: list that omits Task, and a state-consistency check verifies example task Statuses are legal enums, the Task Index and tasks/ agree bidirectionally, and the BUGS.md index matches each per-bug file's Status.
• Handoff-entry cap exception: Reviewer entries and Tester failure entries add one line per finding beyond the fixed fields — for those stages the Handoff Log is the canonical record, and findings are never dropped to fit the cap.
• /agent-code hardening: Pre-Flight resolves the milestone argument to a unique milestone-{N}-* directory (stopping on zero or multiple matches), and sets the milestone README's Status to In Progress when engineering starts, so the Status field is truthful through the whole phase.
• Example fixture restructured to example/artifacts/milestone-1-task-crud/ with five worked task files (task-03 demonstrates the full defect loop through its Handoff Log) and two per-bug files.

Added

• Parallel task execution in /agent-code. Independent tasks — pairwise-disjoint dependencies and Files lists — run their engineering loops concurrently (up to 3 at a time): stages of different tasks overlap while stages within a task stay sequential, all shared-root writes (STANDUP, BUGS index, AGENT_STATE) are orchestrator-serialized via standup:-prefixed queue lines in handoff entries, defect filing runs one chain at a time (bug-ID assignment is racy otherwise), checkpoints serialize, and emergent file overlap pauses the younger task. Sequential execution remains the default whenever a guardrail can't be met.
• Toolset-enforced agent discipline. Every agent's frontmatter now declares an explicit tools: list, and every list omits the Task tool — making the universal "do not spawn subagents" rule a hard guarantee. Lists are otherwise generous per role (engineering agents get Bash; Security additionally gets WebSearch/WebFetch for advisory lookups); an omitted tool is simply unavailable (no error), and explicit lists exclude MCP tools, so the lists are a documented per-project customization point. /cast-init Phase 6 validates presence and the no-Task rule.
• Handoff Protocol rule 6 — the reply channel carries routing metadata only. A stage's report to the orchestrator is a single line (Handoff entry #n appended — outcome; next: stage); the orchestrator routes on it and never re-narrates stage output, keeping the orchestrating context flat across a milestone. Agent rule blocks and both engineering pipelines state it.
• /agent-plan Stage 2c — manifest application. Architecture and UI no longer edit task files directly (they run in parallel and would race); each returns a Manifest Rows block and the orchestrator applies both to the task files in a single-writer step. Revision Handling now also requires re-verifying manifest rows whenever a cited design doc is revised — stale anchors silently defeat the minimal-context contract.
• One-off hygiene. Validator archives Complete one-off/task-*.md files into one-off/archive/ at milestone-completion checkpoints (bug files stay put — the index points at them), and spot-checks BUGS.md index rows against per-bug file Status at session start (bug file wins on mismatch).
• templates/TASK.md — the single-task template (Context Manifest + Handoff Log).
• templates/BUG_REPORT.md — the single-bug template (Report / Investigation / Resolution / Notes).
• /cast-init v1→v2 artifact migration: discovery detects the pre-2.0 by-type layout, Phase 3 proposes a per-file git mv mapping (with the -tasks.md split and BUGS.md index conversion flagged as explicit content transformations for user approval), execution performs it, and validation checks no by-type directories remain.

Process hardening from the v2 gap review (all folded into this release):

• Commit discipline (docs/PIPELINE_LOOP.md → Commit discipline): Coder, Tester, and Refactor commit every stage pass with a task-ID-prefixed message; loop-back fixes stack (never amend); each committing stage's handoff entry carries a Commit field (new optional line in templates/TASK.md); Reviewer reviews the diff over the task's logged commits instead of re-reading whole files; bug files' Resolution → Commit is filled from the stacking fix commit; a validated task's commit run is its independent rollback unit.
• Task-amendment rule (docs/PIPELINE_LOOP.md): when a stage discovers mid-task that scope is wrong (incomplete Files list, unachievable criterion, two-tasks-in-one), it pauses and proposes; Product — as scope owner — approves, splits, or rejects; the loop resumes. No more silent scope expansion and no forced re-plan for in-envelope corrections. Amendments don't increment the loop counter or the circuit breaker.
• Flag-gated implementation reviews at milestone completion: the Stage 3 planning reviews now end with a single flag line — **Implementation review required**: Yes/No in reviews/security.md (Yes for auth, input handling, new dependencies, sensitive data) and **Measured check required**: Yes/No in reviews/performance.md (Yes when budgets apply). Flagged milestones get a security review of the implementation diff (reviews/security-impl.md) and a measured budget check (reviews/performance-impl.md, updating the live AGENT_STATE budget table) at the /agent-code milestone-completion checkpoint, mirroring the UX-review pattern. CI enforces flag → file on completed example milestones.
• Retrospective intake (/agent-plan Stage 1): Product reads the prior milestone's retrospective and disposes of every open improvement action — Adopted → M{N} or Declined — <reason> — into the retrospective's new Disposition column (templates/MILESTONE_RETROSPECTIVE.md). Retrospectives now feed planning instead of being write-only.
• Manifest quality gate and metric: the CEO checklist (templates/CEO_REVIEW.md § 6) verifies every task's Context Manifest is complete and mi...

CAST v1.5.0

Agents now inherit the session model instead of pinning Opus.

Changed

• All 15 agent frontmatter pins replaced with model: inherit. Agents run on whatever model the invoking session uses instead of being hard-pinned to claude-opus-4-8. The Claude Opus 4.x family remains the optimized target (claude-opus-4-8 recommended; claude-opus-4-7 and claude-opus-4-6 supported executing models), and role differentiation still comes from recommended reasoning effort. Explicit per-agent pins remain supported as user overrides.
• Documentation updated to the inherit-by-default policy — root README.md (what-you-get list, Agents placeholder section, prerequisites), agents/README.md, the three pipeline skills' Model Compatibility sections and skills/README.md, docs/MODEL_OPTIMIZATION.md (intro, ladder status, Default Roster Assignment table, effort notes, upgrade paths, verification steps), docs/FIRST_RUN.md's model-access caveat, the adoption skill's canonical structure description, and the roster reference (Model column and summary line). The four xhigh agents' effort notes now say "when the executing model is Opus 4.6" rather than "when pinned".
• Phase 6 validation (check 5) now accepts inherit as the default frontmatter model, with explicit pins (model aliases or full IDs) treated as user-approved overrides.

Added

• Model right-sizing at install time. The README, agents/README.md, references/roster.md, and docs/MODEL_OPTIMIZATION.md now recommend matching each agent's model to its workload to cost-optimize the roster — the most capable model (e.g. opus, or a Fable/Mythos-class model) on the judgment-heavy gates (CEO, Architect, Reviewer, Security), sonnet on the planning-and-implementation loop (Product, UI, Performance, Coder, Tester, Debugger, Refactor), and haiku on the utility roles (Bug Gatherer, Docs Writer, Release, Validator). /cast-init Phase 3 plans now include an Ask item proposing this assignment, and execution step 5.4 applies accepted pins to agent frontmatter during install.

Migration

• Existing installs: in each .claude/agents/*.md, change the frontmatter model: line to inherit (or keep an explicit pin if you rely on one for reproducibility or model-access reasons). Re-running /cast-init after updating applies this automatically.

CAST v1.4.0

Second-pass hardening: a fresh four-track review of v1.3.0 found 40 issues — including two hard blockers introduced by 1.3.0 itself — and all are fixed here. Headlines: fresh adoptions validate again (the 120-char description cap), backend/CLI projects can actually run the pipelines (the UI opt-out deadlock), the retrospective template now installs, the Docs Writer queue has producers, the Deferred lifecycle is defined end-to-end, and the release workflow self-heals. The IMPROVEMENTS.md tracking file was removed at release since every item was resolved.

Fixed (1.3.0 regressions)

• Every fresh adoption failed Phase 6 validation. The 1.3.0 trigger-first agent descriptions run 170–261 characters, but validation check 5 still capped them at 120. The cap is now 300.
• The backend/CLI ui opt-out deadlocked the pipelines. /agent-code Pre-Flight unconditionally required ui-milestone-{N}.md while /agent-plan correctly skipped producing it — each skill sent you to the other. The UI spec is now required only when the ui agent is installed, and CEO_REVIEW.md's UI input/section accept "N/A — no ui agent installed".
• templates/MILESTONE_RETROSPECTIVE.md was never installed — it had no disposition row, so adoption plans omitted the 1.3.0 headline template. Row added; the Phase 5 skeleton count corrected (eleven, not eight).
• The adoption resume path defeated itself twice: Phase 1 archived any prior adoption-plan.md — including the interrupted-run ledger that execution 5.1 resumes from (unchecked ledgers are now preserved as resume candidates); and a run that died after the version stamp (5.8) hit the equal-version "already at " stop rule on re-run (the stop now requires a completed prior run: report present and ledger fully checked).
• Compression damage from the 1.3.0 boilerplate pass: security/performance/docs-writer Model Configs mandated "checklist/profiling/documentation sections" that no longer exist (now cite the sections that do); refactor's "introduce no new abstractions" contradicted its own extract-shared-logic Authority (now scoped to the flagged Issue).

Added

• Docs Writer queue producers. The 1.3.0 drain checkpoints fired on a permanently empty queue — no agent was ever told to enqueue. The eight producer agents (architect, product, ui, coder, performance, debugger, reviewer, refactor) and PIPELINE_LOOP.md Steps 1/3 now instruct appending - <agent> | docs | <note> entries for documentation-worthy changes.
• A complete Deferred lifecycle. Deferred is an open held state (previously "terminal" in BUGS.md and "stays open" everywhere else, simultaneously). Terminal states are Closed / Won't Fix / Duplicate / Cannot Reproduce; "Not a Bug" triage maps to Won't Fix with rationale. Product re-triages Deferred bugs at /agent-code milestone completion and at /agent-plan Stage 1; Deferred Critical/High bugs block release until re-triaged. Task Status enums gained Deferred; Task Selection skips Complete and Deferred tasks; milestones complete when every task is Complete or Deferred ("Complete with Deferrals", with Known Issues listing) — previously a milestone with one deferred task could never complete.
• Retrospective metric sources. validator.md gained a source-mapping table (tasks ← Summary table, violations/conflicts ← AGENT_STATE, revision counts ← Revision History tables, actual duration ← STANDUP session dates, estimated effort ← the milestone definition) and the template's fields now cite those sources — no more unsourceable "planned duration".
• release.yml self-healing and hardening: a run that pushed the tag but failed to publish the Release is now repaired on the next push (tag kept, Release created); a workflow-level concurrency group closes the concurrent-push race; the notes extraction refuses to publish if the top CHANGELOG heading doesn't match the released version; the two accepted divergences from the manual checklist (push-head tagging, unconditional --latest) are documented in the workflow and the release policy.
• CI: five hardened/new checks — payload READMEs (agents/skills) linted against the canonical roster; the roster-description check fails on empty extraction and is row-scoped (was silently green for folded YAML and swapped descriptions); the example structural check derives instance→template pairs from filenames and fails on unmapped or missing wrap-up artifacts; a reverse token lint (payload → README table, with a per-use allowlist); the claude-code CLI pinned.
• Adoption-skill coverage: unattended pre-1.0 upgrades no longer dead-end (downgraded-Delete TODOs count as recorded for validation check 3); non-interactive dry runs waive the Phase 1 confirmation gate; validation greps exclude the cast-init payload itself (no more false positives on project-local skill installs); the version stamp is itself validated (exactly one line, matching metadata.version); the fast path substitutes [MAX_LOOP_COUNT] and the Last-updated date; the rollback recipe actually undoes git mv/git rm (git restore --source=HEAD --staged --worktree); monorepo discovery sweeps workspace members for nested .claude//CLAUDE.md; preserved customizations get a defined home (## Project Customizations (preserved) + AGENT_STATE decision-log row).

Changed

• CEO verdict is a single line — **Verdict**: <APPROVED | APPROVED WITH CONDITIONS | REVISION REQUIRED> replaces the three-checkbox section in which all three verdict strings appeared verbatim in every instance while the skills "keyed on these strings". Both skills parse the line.
• REVISION REQUIRED re-runs Stage 3: architecture-touching revisions re-pass Security + Performance before the CEO re-review, so the CEO never re-reviews against stale findings; Security/Performance gained the CEO revision-request Inputs row the other planning agents got in 1.3.0. /agent-plan's stage triggers are now stated once, identically (Stage 3 starts only after both Architecture and UI complete).
• Validator rescoped, Environment Issues wired: the per-task Process Checklist runs at completion checkpoints or on suspected violations (not as a pre-Product gate nothing invoked); when Tester flags an Environment Issue (now defined in tester.md), the orchestrator invokes Validator mid-loop.
• Per-task validation defined: Product applies the Task Validation Checklist as criteria per task, recording the outcome as task Status plus a STANDUP progress entry; the validation document is milestone-grain only (templates/README's claim that /agent-task uses it was wrong).
• Bug-status ownership reconciled: Duplicate — Bug Gatherer at filing; Cannot Reproduce — Debugger after investigation; BUGS.md's field-ownership table is canonical and both agent files now agree. Tester's residual "suggests a bug" routing got a criterion: out-of-scope defects are filed with Bug Gatherer without interrupting the task; in-scope failures return to Coder.
• Coverage target unified at 80% for new code (tester.md canonical, coder.md consistent; philosophy: acceptance criteria, edge cases, error paths — the 100%/80% contradiction is gone). Release gate wording unified ("no open Critical or High") in release.md's Goals.
• /agent-code opens its STANDUP session heading at Pre-Flight (it wrote entries into no session); STANDUP's worked example now actually conforms to its own grammar. AGENT_STATE guidance clarified everywhere: logs are append-only, current-state cells update in place.
• Token economy: @docs/PRD.md moved to the gated "add once populated" import group (CODE_PATTERNS remains the sole always-on import); /agent-task no longer re-reads CLAUDE.md/CODE_PATTERNS that session imports already loaded. arch-milestone-{N}.md now has a defined contract (instance of ARCH_SYSTEM.md; module/schema templates produce supplementary instances).
• Installed-docs corrections: docs/README's "uncomment the imports" advice replaced with the copy-out-a-bare-@path-line mechanism; subdirectory creation contradiction resolved (pre-created by /cast-init is canonical); TROUBLESHOOTING references in installed docs use the GitHub URL; assorted path-split and ownership wording fixes.
• Example fixture synced to the 1.4.0 shapes: STANDUP rewritten in the canonical grammar with a consistent docs-queue story; new retrospective, UX review, and milestone-validation instances; the CEO review uses the single-line verdict; BUG-002's Deferred story shows the milestone-completion re-triage; example/CLAUDE.md carries the Adopted with CAST v1.4.0 stamp.
• Repo docs: TROUBLESHOOTING.md fully refreshed (conflict priority, import syntax, verdict parsing, resume/upgrade/release-automation entries, UI opt-out entry); README's optional-agents list scoped truthfully, the engineering diagram extended through the task/milestone checkpoints, Quick Start folded into Install, and the placeholder table completed ([TEST_COVERAGE_CMD], [PLATFORM_LIST], [TICK_INTERVAL_MS]).

Migration

• Existing installs: re-run /cast-init (after npx skills update). If you adopted at 1.3.0, this re-run is what delivers the working Phase 6 validation, the retrospective template, and the UI opt-out fix.
• If your project skipped the ui agent (or you want to now): /agent-code no longer demands a UI spec — no workaround files needed.
• Deferred bugs in an existing artifacts/BUGS.md keep their status; the new rule is that Product re-triages them at each milestone completion and Deferred Critical/High block release until re-triaged.
• Hand-written CEO reviews: replace the checkbox Verdict section with the single **Verdict**: <value> line — the skills now parse that line specifically.

---

CAST v1.3.0

Full-system hardening pass: a four-track review of the adoption skill, agent roster, pipeline skills, and packaging produced 45 improvements, all landed here. Headlines: the installed CLAUDE.md's memory imports actually load now, defect routing is stated identically everywhere, the pipelines are resumable and their documented-but-never-invoked stages (Docs Writer, Validator, UX review) are wired in, /cast-init handles re-runs/monorepos/non-git projects, and releases are automated.

Added

• templates/MILESTONE_RETROSPECTIVE.md — milestone retrospectives were previously written into validator.md, violating both the artifacts split and the immutable-agent-file rule. They are now instances at artifacts/reviews/retrospective-milestone-{N}.md, written by Validator at the /agent-code milestone checkpoint.
• [CAST_VERSION] version stamp. /cast-init now stamps Adopted with CAST v<X.Y.Z> into the installed CLAUDE.md (sourced from its own metadata.version) and reads it back on re-runs — the documented upgrade path finally has something to compare against. Forced re-run semantics are defined.
• Adoption-skill coverage for previously undefined situations: monorepo/workspace detection (root-level install default, manifest ambiguity becomes a Phase 3 Ask), non-git projects (explicit confirmation, plain mv, no-rollback warning), same-named agent files with divergent roles (always an Ask, never silent update-in-place), archival of prior adoption records, an explicit execute-approved-Deletes step, a Phase 5 progress ledger with abort/recovery instructions, unattended-mode fallbacks for novel Asks and validation failures, and a documented ui opt-out for backend/CLI-only projects (UI templates skipped iff the agent is skipped; /agent-plan skips its UI stage when no ui agent is installed).
• Pipeline wiring for stages that previously had no invoker: both engineering skills drain the Docs Writer queue at task/milestone checkpoints; Validator is invoked at those checkpoints to record outcomes in artifacts/AGENT_STATE.md; the UX review runs once per UI-flagged milestone at /agent-code milestone completion; Release is explicitly user-invoked.
• Resumability: /agent-code writes task Status back to the milestone tasks file and skips Complete tasks on re-invocation; /agent-plan writes per-stage checkpoints to STANDUP, defines milestone numbering (max existing + 1), and caps the REVISION REQUIRED loop at 3 cycles before escalating.
• .github/workflows/release.yml — on push to main with an untagged plugin.json version: verifies the four synchronized version locations, creates the annotated tag, and publishes the GitHub Release from the top CHANGELOG section; a second job verifies integrity on v* tag pushes. Checklist steps 5–6 are now automated with the manual path as fallback.
• Six new CI checks in validate.yml: README placeholder-table tokens must exist in the payload; example/ must be token-free; docs/templates/artifacts path-split lint; offline relative-link check; example instances must carry their template's required headings; agent model pins must be identical. Manifests are validated with claude plugin validate instead of bare JSON.parse.

Changed

• Installed CLAUDE.md memory imports fixed. The template used @import docs/X.md, a syntax Claude Code does not support — every adopted project silently loaded no core context. Imports are now bare @docs/X.md lines; commented suggestions use inert code spans; /cast-init validation now checks the syntax and that imported paths exist.
• Defect routing stated identically everywhere. Canonical flow: Reviewer → Bug Gatherer (files report, status New) → Product triage (Fix Now → Debugger → Coder; Defer — allowed only when acceptance criteria are unaffected, task proceeds; Not a Bug — closed with rationale). reviewer.md, debugger.md, tester.md, bug-gatherer.md, and docs/PIPELINE_LOOP.md all previously contradicted this in different ways; Tester failures route to Coder only. "Clean version" = no open Fix Now defects.
• All 15 agent frontmatter descriptions rewritten trigger-first for Claude Code subagent auto-discovery (e.g. Tester: "Use PROACTIVELY after every Coder change"), and the roster table in references/roster.md synced verbatim (CI-enforced).
• Agent Model Configuration boilerplate compressed from ~8–10 duplicated lines per file to ~2, with every behavioral constraint kept in-file and the shared model-ladder rationale consolidated in docs/MODEL_OPTIMIZATION.md (~100+ lines removed across the roster).
• Cross-agent contract fixes: Architect/Product/UI Inputs tables now receive Security/Performance findings and CEO revision requests; Coder hands off to Tester (not Product); Release gates on "Critical or High" (the 4-level scale — "Major" existed nowhere); Security's Informational findings are review-document-only (never filed as bugs); docs/CHANGELOG.md has a single owner (Release; Docs Writer routes through it); CI/build infrastructure and dependency maintenance have assigned owners; Release's checklist gains the security pre-release gate.
• One STANDUP entry grammar (### YYYY-MM-DD — <skill> — <milestone/task> sections with - <agent> | <type> | <note> entries; types progress/loop/docs/decision/blocker) replaces the four incompatible formats previously implied by STANDUP.md, agent-task, PIPELINE_LOOP, and the roster README.
• CEO Approval Conditions are backfilled into the milestone tasks file by Product after the verdict; /agent-code Pre-Flight reads them from there. Product (not the orchestrator) writes completion and validation records.
• Naming/path corrections: artifact instance names unified to lower-hyphen (module-{slug}.md, screen-{slug}.md, new component-{slug}.md), STANDUP's related-documents links fixed, "Work Queue" renamed to AGENT_STATE's actual "Current Work — Ready to Start", validator.md's stale "Product's file" reference fixed, path-split wording bugs in security.md/docs-writer.md corrected.
• README placeholder table pruned of 22 dead tokens (also from references/execution.md/discovery.md substitution lists) and gains [CAST_VERSION] + [MAX_LOOP_COUNT]; the docs/ "never receives work" wording now carries the docs/CHANGELOG.md carve-out; the plugin-route asymmetry (full repo in the plugin cache) is documented; /artifacts/ is gitignored at the repo root.
• Example fixture synced to the 1.2.0 template contracts: milestone definition, tasks file, architecture doc, UI spec, and CEO review all restructured to their templates' required sections (CI-enforced from now on); stray [MILESTONE_NAME] token removed; example imports fixed to the working syntax and trimmed to files the fixture ships.
• /cast-init validation hardening: placeholder grep scoped to the installed file set with templates/* exempt; new ui-agent ⇔ UI-templates consistency check; import-syntax check; Phase 7 closing summary and report parameterized for staged/partial/failed outcomes.

Migration

• Existing installs: re-run /cast-init (after npx skills update). The memory-import fix alone is worth it — installs adopted from any earlier version load no docs/ context at session start. The re-run also delivers the corrected defect routing, the retrospective/UX-review/Docs-Writer wiring, and stamps the version for future upgrades.
• If you customized reviewer.md, debugger.md, tester.md, or docs/PIPELINE_LOOP.md, review the merge: the defect-routing and triage-outcome wording changed in all four.
• validator.md no longer accumulates retrospectives in place; move any existing ones to artifacts/reviews/retrospective-milestone-{N}.md.

---