git:20260826.bdc404f to git:20260906.ac21bc2

40 added, 139 removed. Audit B to A.

What this update changes in the checks

This update trips no new check.

It clears 1 check: No link to a raw IP address.

A tripped check is a label, not a verdict: read the matched text and the lines below. This week's updates that newly trip a check.

---
name: development-team
- description: How the development pod coordinates implementation, QA, and design without skipping gates.
+ description: Use when a development pod begins or hands off implementation, QA, or design work.
---
# Development Team
- You are part of the development pod. Your shared job is to turn product direction into working software without guesswork, hidden assumptions, or skipped review gates.
-
- ## Startup sequence
-
- Before the pod starts real implementation:
- - load the packaged skills named in your role startup checklist
- - run `rig whoami --json`
- - confirm who is playing implementer, QA, and design in this run
- - wait for the orchestrator's real assignment instead of freelancing off a partial guess
-
- The development pod should feel like a real working pod, not three isolated agents improvising alone.
-
- ## Pod shape
-
- The development pod may include:
- - an implementer who writes the change
- - a QA partner who gates every edit
- - a designer who clarifies product behavior and UX before implementation fills in the blanks
-
- Some starters only launch the implementer and QA. Others also launch a designer. The workflow stays the same: clarify first, implement deliberately, verify independently.
-
- ## Shared loop
-
- This is the default loop for product work:
-
- ```
- 1. Clarify the work and the acceptance criteria
- 2. Implementer sends a pre-edit proposal to QA
- 3. QA approves or rejects with specifics
- 4. Implementer changes code with TDD
- 5. Implementer sends the diff and verification output back to QA
- 6. QA approves or rejects with specifics
- 7. If commit authority is enabled, the implementer may commit
- 8. If commit authority is not enabled, stop at a QA-approved working tree and report that state clearly
- ```
-
- Skip no gates. If the task is ambiguous, resolve the ambiguity before editing.
-
- **Chunk size points up — keep TDD's shape, not its ping-pong cadence (2026-08).** Frontier agents handle
- large, long-horizon, goal-oriented chunks — an hour-plus of complex work — without fragmenting. So don't
- default to tiny pieces: **keep TDD's *shape* (two sets of eyes, the guard structure, red before green)
- but treat chunk size and cadence as a configured LEVER, not a habit.** Classic small back-and-forth
- ping-pong is unnecessary overhead when the loop's own gates (QA, review, guards) already bound a larger
- chunk's risk. The sweet spot is task-dependent, much larger than it used to be, and rising. See
- `test-driven-development` for the shape that stays fixed.
-
- ## What the implementer must hand QA
-
- Pre-edit proposal should include:
- - the files expected to change
- - the behavior or acceptance criteria being targeted
- - the first failing test or verification step
- - any likely edge cases or invariants
-
- Post-edit review bundle should include:
- - what changed
- - the actual verification commands run
- - the result of those commands
- - any remaining uncertainty or follow-up risk
-
- QA should not have to reverse-engineer what the implementer thought they were doing.
-
- ## Implementer
-
- Before proposing:
- - read the task fully
- - inspect the relevant code before promising a solution
- - name the files, tests, and acceptance criteria in the proposal
-
- After QA rejection:
- - read the exact feedback
- - fix the issue instead of arguing around it
- - resubmit with the changes called out explicitly
-
- ## QA
-
- QA is not a rubber stamp. QA is a product voice — not just a test gate.
-
- When reviewing a proposal:
- - reject if the scope is wrong
- - check whether the planned tests actually prove the contract
- - flag hidden risks and missing failure cases
-
- When reviewing a diff:
- - read the actual code, not just the summary
- - verify independently when possible
- - if you cannot verify independently, require real output in the review bundle and inspect it critically
-
- If the implementer stalls on a permission or approval prompt, call that out immediately. Do not treat a blocked pane as finished implementation.
-
- ### QA dogfood mode
-
- When QA is dogfooding (testing existing features rather than gating new code), QA works solo with full autonomy:
- - find issues AND fix them in a loop
- - test the fix, then move to the next issue
- - only escalate architecture-level concerns to the orchestrator
- - do not wait for approval to fix obvious bugs during dogfood
- - report findings to the chatroom so the rig has visibility
-
- ### QA as a product voice
-
- QA sees the product from the user's perspective. When QA has insights about naming, UX, error messages, or workflow coherence, those are product contributions — not just defect reports. The orchestrator should give QA architecture input, not limit QA to test gating.
-
- ## Designer
-
- When present, the designer should work ahead of implementation:
- - turn vague goals into concrete flows, states, copy, and interaction choices
- - surface edge cases before engineering has to guess
- - review built results for coherence, not just visual polish
-
- The designer is part of the development pod, not a decorative sidecar.
-
- ## Browser testing and dogfood tools
+ The pod turns the assigned user outcome into working software. Builders, QA and
+ designers are capabilities; neighboring roles may be held by one seat unless
+ independence was explicitly selected.
- The development pod has access to browser automation and structured dogfood testing tools:
+ ## Start from the work
- - **`agent-browser`** — browser automation CLI. Navigate to the daemon UI, snapshot interactive elements, take annotated screenshots, record repro videos. Use `agent-browser open <url>`, `agent-browser snapshot -i`, `agent-browser screenshot --annotate`.
- - **`dogfood`** — structured exploratory testing workflow. Produces a report with screenshots, repro videos, and step-by-step evidence for every finding.
+ Run `rig whoami --json`, then resolve `project.yaml -> mission.yaml -> active
+ slice.yaml -> selected component or wave map -> addressed context`. The complete
+ lookup and precedence rule is `docs/reference/product-journey-sdlc.md#resolve-the-selected-path`
+ (installed: `$OPENRIG_HOME/reference/product-journey-sdlc.md#resolve-the-selected-path`).
+ Read the selected addresses and source needed for this task; skills available in
+ your profile are capabilities, not a mandatory reading list. No composition means
+ light Part A. Role names and idle seats add no gates. Explicit rigor and authored
+ wave boundaries retain their named checks.
- QA typically drives browser and dogfood testing, but both impl and QA should know these tools exist and can use them. When dogfooding UI:
- 1. Load `/agent-browser` and `/dogfood`
- 2. Open the daemon UI: `agent-browser open http://127.0.0.1:7433`
- 3. Systematically explore surfaces, take screenshots as proof
- 4. Report findings using the PASS/FAIL/GAP format to the chatroom
+ ## Build and verify
- ## When the pod is blocked
+ Clarify consequential uncertainty, inspect the existing seam, then complete one
+ coherent outcome. Reproduce a defect before repairing it; use tests that distinguish
+ the failure and verify through the public surface. Keep chunks as large as the
+ outcome and file territory permit. TDD is a feedback loop, not a two-seat protocol.
- If the blocker is:
- - ambiguity: pull in design or ask the orchestrator for clarification
- - failing tests / unexpected behavior: use `systematic-debugging`
- - code changes: use `test-driven-development`
- - completion claims: use `verification-before-completion`
+ The builder reports the exact candidate, changed behavior, commands and observed
+ results, with remaining uncertainty. No universal pre-edit proposal, QA approval
+ or post-edit gate is implied. When one is explicitly selected, honor its boundary
+ and send the relevant evidence directly to its owner.
- Do not hand-wave around blockers. Name them and route them.
+ ## QA and design
- ## Communication
+ QA compares the delivered behavior with the actual contract. Read the diff and
+ exercise the result; avoid tests that merely repeat the implementation. On a tiny
+ change the builder may hold QA. Independent QA excludes the author when selected.
+ A wave receives independent review at its authored boundary, not per slice.
- - Pre-edit proposal: `rig send <qa-session> "PRE-EDIT: ..." --verify`
- - Review bundle: `rig send <qa-session> "REVIEW BUNDLE: ..." --verify`
- - Design clarification: `rig send <design-session> "Need product/design input on ..." --verify`
+ Design clarifies user flows and ambiguous behavior when the outcome needs it.
+ Browser and dogfood skills load for a relevant UI journey, not every task. During
+ assigned dogfood, fix-and-retest only within the granted scope; a read-only
+ assignment stays read-only. If a tester becomes an author, preserve that attribution
+ when independent evaluation is required.
- ## When blocked
+ ## Blockers and return
- If permissions block tests, file access, or commits:
- 1. identify the exact blocked command
- 2. tell the human what that prevents
- 3. continue with the work you can still do
+ Use `systematic-debugging` for an unexpected failure and
+ `verification-before-completion` before claiming success. A permission prompt is
+ a concrete blocker; report the command and consequence instead of labeling it
+ progress. A missing decision goes to the owner who can settle it.
- Do not silently stall. Do not pretend blocked verification is complete.
+ Return the candidate and evidence through the selected handoff. Do not create
+ obligations just to keep an idle QA, guard or reviewer occupied. Quality is a
+ working product with honest evidence, not the number of transfers.