Activities - Manage Iteration

#	Name	Abbrev.	Guidance	Actions
1	Activate Iteration	MIN-1	Purpose Activate the iteration from a single human trigger. Confirm the correct PIN manifest exists …	Read the 'MIN-1 Activate Iteration' activity from playbook 'Junior Edda' (workflow 'Manage Iteration'). Follow its guidance when assisting me. ## Purpose Activate the iteration from a single human trigger. Confirm the correct PIN manifest exists for the requested milestone, validate PIN readiness (no contradictory or non-executable scenarios), assert every issue is open and queued, and declare a clean execution slate. Trigger: user says "Work on Milestone #N" or "Work on Milestone <name>" ## Step 0 — Locate Milestone-Bound Manifest (do this FIRST) Find the manifest using the `milestone_number` or `milestone_title` fields written by the Publish activity in Plan Iteration. Do NOT use "newest file" or `ls -t \| head -1`. ```bash # When user provides a milestone number (#N): grep -l "milestone_number: {N}" docs/plans/iterations/ITER-.yaml 2>/dev/null # When user provides a milestone name or fragment: grep -rl "milestone_title:.{title_fragment}" docs/plans/iterations/ITER-.yaml 2>/dev/null ``` If no matching manifest: > STOP.* No manifest bound to this milestone. Tell user: "Run Plan Iteration for milestone '{name}' first, then invoke Manage Iteration." If `milestone_number: null` (or field absent) in the matched file: the Publish activity did not complete its manifest update. Tell user: "Plan Iteration Publish step did not write the milestone number back to the manifest. Re-run Publish Step 5, then invoke Manage Iteration." If multiple matches: confirm with user which manifest to use. Record the selected manifest path. All subsequent steps use this file only. ## Step 1 — Find and Lock the Milestone ```bash gh milestone list --json number,title,state \| jq '.[] \| select(.state == "open")' ``` Match to exactly one open milestone. Store `{milestone_number}` and `{milestone_title}`. Multiple matches or no match → stop and ask user to clarify. Cross-check: confirm the manifest's `milestone_number` matches `{milestone_number}` AND `milestone_title` matches `{milestone_title}`. Any mismatch → stop and report. ## Step 2 — PIN Readiness Validation Before touching any issue, validate that the manifest scenarios are executable: ```bash cat {selected_manifest} \| grep -A1 'feature_file_paths' \| grep '\.feature' ``` For each `feature_file_paths[]` entry, verify: - [ ] The `.feature` file exists on disk - [ ] Each `Scenario:` title is unique within that file - [ ] URLs referenced in steps are consistent (flag alternating paths as a spec conflict) - [ ] No scenario step is irreducibly vague — flag and ask user before proceeding If any conflict or ambiguity is found: > STOP. List each conflict with file + line reference. Tell user: "Plan Iteration produced contradictory or non-executable scenarios. Reconcile these before Manage Iteration can run." Do not proceed past this step with unresolved spec conflicts. ## Step 3 — Confirm Issues + Sprint-Size Guard Fetch each issue one at a time: ```bash gh issue view {github_issue} --json number,title,labels,state ``` Confirm each is `open` with `status-queued`. Report discrepancies. Sprint-size guard: ```bash gh api repos/{owner}/{repo}/milestones/{N} --jq '.open_issues' ``` If `open_issues > 15`: warn and require explicit user confirmation before continuing. ## Step 4 — Assert Clean Slate ```bash gh issue list --milestone {N} --label "status-in-progress" --json number,title ``` If any `status-in-progress` exists: prior session interrupted. Re-run its last `gate.command`. PASS → close issue, continue. FAIL → one retry → escalate. ## Step 5 — Verify Iteration Branch ```bash git branch -a \| grep "iteration/{milestone-slug}" ``` If absent: > STOP. Tell user: "Plan Iteration Contract step did not create an iteration branch. Re-run Contract Step 1 or create the branch manually before invoking Manage Iteration." Check out the iteration branch: ```bash git checkout iteration/{milestone-slug} ``` ## Step 6 — Output Activation Summary ``` === ACTIVATION === Manifest: {selected_manifest} (milestone_number: {N}, milestone_title: {title}) Milestone: #{N} \| {goal} Branch: iteration/{slug} Issues: {N} open, all status-queued Size: {ok \| WARNING: {N} issues — user confirmed} Spec: {N} feature files checked, {conflicts} conflicts, {vague} vague steps Slate: clean Next: Load Context from PIN Artifacts ================== ``` ## Success Criteria - Manifest located by `milestone_number` or `milestone_title` field (not by file order) - `milestone_number` is a concrete integer in the matched manifest (not null or absent) - Manifest `milestone_number` + `milestone_title` cross-checked against the live milestone - PIN readiness validation passed (no unresolved spec conflicts or vague steps) - Iteration branch confirmed and checked out - All issues confirmed open with `status-queued` (fetched individually) - Sprint-size warning shown if > 15 issues; user confirmed - No dangling `status-in-progress`, or resume path taken
2	Load Context from PIN Artifacts	MIN-2	Purpose Restore the distilled context that Plan Iteration already built, then derive and present the …	Read the 'MIN-2 Load Context from PIN Artifacts' activity from playbook 'Junior Edda' (workflow 'Manage Iteration'). Follow its guidance when assisting me. ## Purpose Restore the distilled context that Plan Iteration already built, then derive and present the full execution queue. Pure pre-flight — no implementation, no GitHub mutations. This activity absorbs the sequencing responsibilities of the dropped 'Sequence from Manifest' activity: loading context and building the execution queue share the same actor (TL), the same input (the iteration manifest), and the same exit condition (execution queue ready to dispatch). Do NOT re-read SAO.md, BDD specs, or mockups from scratch. ## Part A — Load Context ### Step 1: Load the Milestone-Bound Manifest Use the manifest path identified and locked in Activate Iteration. Do not re-select. Do not use `ls -t \| head -1`. ```bash cat {manifest_path_from_activate_iteration} # already on disk; read it directly ``` Extract per scenario: `id`, `title`, `github_issue`, `parallel_group`, `codebase_footprint[]`, `context_map[]`, `do_not_do[]`, `checkpoint.command`, `checkpoint.log_story_command`, `feature_execution_graph` (nodes: `id`, `bpe`, `depends_on`, `footprint[]`, `gate`), `dependencies[]`, `feature_file_paths[]`, `system_dependencies[]`. Verify that each scenario's `github_issue` is on the current milestone (cross-check with Activate Iteration's confirmed issue list). Any issue not in the milestone list → flag before proceeding. ### Step 2: Load Orient Summary ```bash ls -t docs/plans/iterations/pin-orient-.md 2>/dev/null \| head -1 ``` If none: first-iteration defaults (`velocity_trend: unknown`, `scope_risks: none`). Continue. If found: read it. Extract velocity trend, scope risks, watch-fors. ### Step 3: Spot-Check Context Map For 1-3 `context_map` entries per scenario: ```bash wc -l {file} # confirm file exists and has sufficient lines ``` Missing file → flag as potential sao_violation. ### Step 4: Check System Dependencies For each `system_dependencies[]` item, verify it exists in the codebase. If absent: STOP* and escalate before any implementation. ## Part B — Sequence ### Step 5: Parse Parallel Groups + Conflict Map From the manifest: extract `parallel_groups` and `conflict_map`. Do not recompute — Plan Iteration Contract derived these from actual skeleton commits. ### Step 6: Check Dependency State Per Scenario For each scenario, fetch each `dependencies[]` issue individually: ```bash gh issue view {N} --json number,state,labels ``` Mark each READY (no deps, or all deps closed with status-done) or BLOCKED. ### Step 7: Build Execution Queue Order: Group A → Group B → Group C. Within each group: READY before BLOCKED. ### Step 8: Output Execution Plan (Plan Mode) Switch to Plan Mode. Present: Outer — scenario dependency graph (Mermaid flowchart) Inner — for each READY scenario, feature_execution_graph node dependencies ``` === CONTEXT LOADED === Manifest: {path} — bound to milestone #{milestone_number} Orient: {filename or "first iteration"} \| velocity_trend: {value} Scenarios: {N} total System deps: {list or "none"} Spot-check: {N}/{N} context_map refs confirmed === EXECUTION QUEUE === Groups: {N} \| Ready: {N} \| Blocked: {N} {queue with nodes per scenario} First ready nodes: {list} Conflicts: {file shared by SN, SM — serialized} Next: Execute (TL Dispatches Workers) ======================= ``` ## Success Criteria - Manifest loaded from the path locked in Activate Iteration (not re-selected) - Every scenario's `github_issue` confirmed on the milestone - All per-scenario fields extracted - System dependencies verified; escalation if absent - Parallel groups + conflict map parsed (not recomputed) - Execution queue ordered; Mermaid diagrams presented
3	TL Dispatches Workers to Build	MIN-3	Model Tiers Role Model tier Responsibility Team Lead (TL) Advanced reasoning model Sequences queue, dispatches …	Read the 'MIN-3 TL Dispatches Workers to Build' activity from playbook 'Junior Edda' (workflow 'Manage Iteration'). Follow its guidance when assisting me. ## Model Tiers \| Role \| Model tier \| Responsibility \| \|------\|-----------\|----------------\| \| Team Lead (TL) \| Advanced reasoning model \| Sequences queue, dispatches workers, reviews NODE_PASS, handles drift — writes no feature implementation code \| \| dr-dobbs (Worker) \| Cheap-fast model \| Implements one graph node per invocation, commits its changes, runs gate, posts NODE_PASS or NODE_FAIL, stops \| TL authority on code: TL may fix trivial presentation issues inline (e.g. add a missing `data-testid` attribute to an HTML element, correct an import order). TL may NOT write new logic, new methods, new tests, or multi-line implementation — that is dr-dobbs work. When in doubt: dispatch a worker. Worker isolation: Each worker operates on the shared iteration branch. Workers with overlapping `footprint[]` files are serialized by the `conflict_map` (already computed by PIN). Do not dispatch workers that share files in the same parallel slot. Workers must commit their own footprint before posting NODE_PASS to prevent dirty-tree races. --- ## Step 1: Verify Iteration Branch Is Checked Out ```bash git branch --show-current # must match iteration/{milestone-slug} git status # must be clean before any dispatch ``` If dirty: do not dispatch. Identify and commit or stash uncommitted changes from a prior session. ## Step 2: Pick the Next READY Issue From the execution queue (MIN-02), select the next READY scenario respecting group order A → B → C and `conflict_map` constraints. Claim: ```bash gh issue edit {N} --add-label "status-in-progress" --remove-label "status-queued" gh issue comment {N} --body "<!-- EXECUTION_START -->\nStarted: {ISO8601}\nBranch: iteration/{slug}\n<!-- /EXECUTION_START -->" ``` ## Step 3: Read the Feature Execution Graph ```bash gh issue view {N} --json number,title,body,labels ``` Parse `<!-- FEATURE_EXECUTION_GRAPH -->` from issue body. Extract all nodes and identify the first ready nodes (no `depends_on`, or all deps already NODE_PASS). ## Step 4: Dispatch Worker Subagents (one per ready node) For each ready node, assemble the dr-dobbs task prompt. Commit type mapping (use as `{bpe_type}` in the commit message below): \| Node `bpe` value \| Commit type \| \|-----------------\|-------------\| \| BPE-02, BPE-03 \| `feat` \| \| BPE-04, BPE-05 \| `test` \| \| BPE-06 \| `chore` \| The prompt must include an explicit commit step: ``` You are dr-dobbs — cheap-fast implementation worker on iteration branch: iteration/{slug}. Implement ONLY node {node_id} for issue #{N}. 1. Confirm you are on the correct branch: git branch --show-current # must be iteration/{slug} 2. Read the issue: gh issue view {N} --json number,title,body,labels 3. Assemble guidance bundle per skill "Assemble Guidance Bundle" for this node. 4. Implement only footprint[]: {footprint_list} - Fill raise NotImplementedError() stubs. Do NOT change method signatures. - If new models: run makemigrations && migrate before gate. 5. Run gate: {gate.command} {gate.log_story_command if declared} 6. If gate PASS: a. git add {footprint_files} b. git commit -m "{bpe_type}({scope}): {node_id} — {issue_title} (#{N})" (bpe_type: feat for BPE-02/03, test for BPE-04/05, chore for BPE-06) c. Post NODE_PASS: <!-- NODE_PASS --> node: {node_id} gate: {command} — exit 0 commit: {sha} <!-- /NODE_PASS --> d. Stop. Do not continue to the next node. 7. If gate FAIL: one targeted fix, retry gate once. PASS → commit and NODE_PASS as above. FAIL → post NODE_FAIL (with error excerpt) and stop. Do NOT: change signatures, touch files outside footprint[], create files not in skeleton, pick up another node. ``` Launch as a fresh Task subagent (cheap-fast model). Never resume a prior worker. ## Step 5: Monitor and Advance the Node Graph On NODE_PASS: confirm the commit SHA is present in the comment. Check which nodes are newly unblocked; dispatch workers. Continue until all nodes show NODE_PASS. On NODE_FAIL (after worker's internal retry): post absorbed drift comment; dispatch one TL-guided targeted fix subagent. If that also fails: escalate with `drift-escalated` label. On footprint violation: escalate immediately. ## Step 6: Handoff to MIN-04 ```bash gh issue comment {N} --body "<!-- BUILD_COMPLETE -->\nAll nodes NODE_PASS.\nBranch: iteration/{slug}\nReady for: MIN-04\n<!-- /BUILD_COMPLETE -->" ``` Begin MIN-04 for this issue. Parallel scenarios: MIN-04 may process one while MIN-03 dispatches nodes for another, provided they don't share files. ## Drift Table \| Signal \| Threshold \| Action \| \|--------\|-----------\|--------\| \| gate fail \| first \| worker retries once internally \| \| gate fail after retry \| second \| TL dispatches targeted fix worker \| \| gate fail after TL fix \| third \| ESCALATE \| \| footprint violation \| any \| ESCALATE immediately \| \| time overrun \| > 2x per node \| ESCALATE \| \| same node, 2+ absorbed \| — \| ESCALATE \| ## Success Criteria - Iteration branch confirmed clean before any dispatch - TL wrote no feature implementation code - Every worker committed its footprint files before posting NODE_PASS - Each NODE_PASS comment contains a commit SHA - Parallel nodes dispatched only where conflict_map allows (no file overlap) - All issues have BUILD_COMPLETE comment ## Agent dr-dobbs (Worker) — cheap-fast model. One node per invocation. Fills NotImplementedError stubs in declared footprint[]. Commits footprint. Runs gate. Posts NODE_PASS with SHA. Stops. Team Lead (Orchestrator) — advanced reasoning model. Reads queue, dispatches, reviews NODE_PASS commits, handles drift. No feature code. ## Skill - Assemble Guidance Bundle - Pytest Log Story Assertions (when log_story_command declared) ## Rules `do-skeletons-first`, `do-test-first`, `do-not-mock-in-integration-tests`, `do-informative-logging`, `do-assert-log-story`, `do-write-concise-methods`, `do-follow-commit-convention`, `do-small-increments`, `pytest`
4	TL Integrates and Gates Each Feature	MIN-4	Purpose For each issue that posts BUILD_COMPLETE: verify the DoD node already ran (do not …	Read the 'MIN-4 TL Integrates and Gates Each Feature' activity from playbook 'Junior Edda' (workflow 'Manage Iteration'). Follow its guidance when assisting me. ## Purpose For each issue that posts BUILD_COMPLETE: verify the DoD node already ran (do not re-run it), run BPE-07 Finalize Feature (Activity 102 in the Build Feature workflow), and close the issue. When all issues are closed, open the iteration PR for human review. TL may fix trivial presentation issues inline only — no logic, no new tests. Runs interleaved with Execute: as soon as an issue posts BUILD_COMPLETE, start its gate cycle. --- ## TL Code Authority TL may fix inline (without dispatching a worker): - Adding a missing `data-testid` attribute to an existing static HTML element - Correcting an import order violation - Fixing a commit message format TL must dispatch a dr-dobbs worker for: - Any fix that touches logic, queries, or view code - Any missing or broken test - Any method that needs to be created or modified This authority is consistent with Execute (Activity 181). dr-dobbs workers dispatched from this activity operate under the same isolation rules as in Activity 181. --- ## Per-Issue Cycle ### Step 1: Verify All Nodes Committed and NODE_PASS ```bash # Count NODE_PASS comments — must equal total node count in the graph gh issue view {N} --json comments \| jq '[.comments[] \| select(.body \| contains("NODE_PASS"))] \| length' # Verify each NODE_PASS contains a commit SHA gh issue view {N} --json comments \| jq '[.comments[] \| select(.body \| contains("NODE_PASS")) \| select(.body \| contains("commit:"))] \| length' ``` Both counts must equal `total_nodes`. If any NODE_PASS is missing a commit SHA: return to Execute (Activity 181) to dispatch a cleanup worker. ### Step 2: Verify the BPE-06 DoD Node Ran BPE-06 (Check Definition of Done, Activity 101 in Build Feature workflow) was dispatched as a terminal node by Execute (Activity 181). Do not re-run the full checklist. Instead, verify it passed: ```bash gh issue view {N} --json comments \| jq '[.comments[] \| select(.body \| contains("NODE_PASS")) \| select(.body \| contains("BPE-06"))] \| length' ``` If the BPE-06 node did not post NODE_PASS: return to Execute (Activity 181) to dispatch it. If BPE-06 NODE_PASS is present, run a lightweight regression: ```bash pytest tests/ -x --ignore=tests/e2e -q 2>&1 \| tail -5 ``` Green → proceed. Red → dispatch targeted dr-dobbs fix worker, rerun. ### Step 3: Run BPE-07 — Finalize Feature Apply BPE-07 (Finalize Feature, Activity 102 in Build Feature workflow): 3a. Full test suite: ```bash pytest tests/ -x --ignore=tests/e2e ``` 100% pass rate required. Any failure: dispatch targeted dr-dobbs fix worker, rerun. 3b. Dependencies: no new packages missing from `requirements.txt`. 3c. Scenario terminal checkpoint: ```bash {checkpoint.command} # from manifest ``` Must exit 0. One fix attempt → retry → escalate. 3d. Finalize commit (if anything changed during gate): ```bash git add -A git commit -m "chore({scope}): BPE-07 finalize for #{N} — {feature_title}" ``` ### Step 4: Close Issue ```bash gh issue close {N} --comment "<!-- GATE_PASS -->\nBPE-06 node: NODE_PASS (worker-run)\nBPE-07: PASS\nCheckpoint: PASS\nBranch: iteration/{slug}\nReady for: Acceptance\n<!-- /GATE_PASS -->" gh issue edit {N} --remove-label "status-in-progress" --add-label "status-done" ``` ### Step 5: Advance the Queue Check Execute (Activity 181) for newly unblocked BLOCKED scenarios. --- ## Exit Gate — All Issues Integrated When all issues on the milestone are closed: ```bash gh issue list --milestone {N} --state open --json number \| jq 'length' # must return 0 ``` Then open the iteration PR: ```bash gh pr create \ --base main \ --head iteration/{slug} \ --title "Iteration {slug}: {goal}" \ --body "## Delivered\n{scenario list with issue links}\n\n## Gate\nAll issues: NODE_PASS + BPE-06 node + BPE-07 PASS\n\n## Next\nAcceptance testing runs on this branch before merge." ``` Record the PR number. Proceed to Acceptance (Activity 183 — Saga UAT on the iteration branch, do not merge yet). ## Success Criteria - Every NODE_PASS comment contains a commit SHA - BPE-06 node verified (worker-run via Execute, not re-executed by TL) - Regression suite green before each issue closes - BPE-07 Finalize applied per issue - All issues status-done with GATE_PASS - Iteration PR opened against main ## Agent None — TL inline. May dispatch targeted dr-dobbs workers for regression failures or missing BPE-06 node. ## Rules `do-test-first`, `do-not-mock-in-integration-tests`, `do-informative-logging`, `do-assert-log-story`, `do-follow-commit-convention`
5	Acceptance, Bug Reports & Deploy Fixes	MIN-5	Purpose Saga (UAT Agent) executes acceptance tests scoped strictly to the scenarios delivered in this …	Read the 'MIN-5 Acceptance, Bug Reports & Deploy Fixes' activity from playbook 'Junior Edda' (workflow 'Manage Iteration'). Follow its guidance when assisting me. ## Purpose Saga (UAT Agent) executes acceptance tests scoped strictly to the scenarios delivered in this iteration, classifies every defect, files bug reports for blockers, and produces a UAT Report with a routing verdict. Replaces the semi-manual acceptance walkthrough with a fully-agentified, project-agnostic UAT step. ## Model Tier Saga (UAT Agent): medium reasoning model. Executes tests literally within declared scope. Classifies every failure. Never skips an assertion. Never expands scope beyond the iteration manifest. --- ## Precedence Rule (read before anything else) When test evidence conflicts with specifications: 1. Accepted feature spec (`docs/features/` files listed in `feature_file_paths[]`) — authoritative 2. Manifest contract (ITER-.yaml scenario definition) — implementation contract 3. tests/uat or tests/e2e scripts* — current behavior; may be stale relative to specs If a test assertion conflicts with the feature spec: the spec wins. File a `test-debt` issue for the stale test. Do NOT file it as a bug against the implementation. --- ## Step 1: Determine Scope Saga tests only what the iteration delivered. Scope is fixed by the manifest: ```bash cat {manifest_path} \| grep -A50 'feature_file_paths' ``` This list is Saga's test scope. Saga does NOT discover or run tests/uat/ or tests/e2e/ wholesale. ## Step 2: Survey the Test Landscape (within scope) For each feature in scope: \| Found \| Mode \| \|-------\|------\| \| `test_.py` or `.feature` + step defs in `tests/e2e/` \| Automated — run test runner \| \| Journey scripts in `tests/uat/` matching this feature \| Scripted — execute only those scenarios \| \| Only `docs/features/` with no test files \| Exploratory — derive from feature spec \| Scripted mode: when `tests/uat/` covers multiple features, execute ONLY scenarios whose `feature_file_paths[]` entry matches this iteration. Skip all others. Exploratory mode: file a `test-debt` issue recommending test file creation. ## Step 3: Pre-conditions - Server running on the iteration branch (not main) - Health check passes before any browser action - Required seed data present - For MCP tool calls: MCP server running and accessible ## Step 4: Execute Tests (per mode, per feature in scope) Automated: ```bash pytest tests/e2e/ -k "{feature_keywords}" -v ``` Scripted: Follow the journey script(s) for this feature's scenarios only: 1. Execute each DO step via browser automation or MCP tool call 2. Assert each SEE condition 3. On RECORD: capture and store placeholder value 4. On CURSOR_PROMPT: stop, display step to user, await confirmation, continue 5. On assertion failure: classify and file (Step 5) Exploratory: For each scenario in the feature spec: 1. Walk the happy path via browser automation 2. Walk the reject path (wrong credentials, empty inputs, boundary values) 3. File any unexpected behavior as a defect ## Step 5: Defect Classification and Reporting \| Severity \| Definition \| \|----------\|------------\| \| Blocker \| Core feature path broken; journey cannot continue \| \| Major \| Feature works but wrong message/redirect/UX; journey continues \| \| Minor \| Cosmetic, label mismatch; journey continues \| \| Test-debt \| Test assertion is stale (conflicts with accepted feature spec) \| ```python report_bug( description=( f"{feature_id} / {scenario_title} — {step_description}\n\n" f"Spec says: {feature_spec_assertion}\n" f"Observed: {actual}\n" f"Severity: {severity}\n" f"Evidence: {screenshot_or_log}" ), page_context=f"Acceptance — milestone #{N} — branch iteration/{slug} — {ISO8601}" ) ``` ```bash gh issue edit {bug_number} --milestone {N} --add-label "bug,{severity}" ``` Test-debt issues: label `test-debt`, no `bug` label, do not count toward blocker total. ## Step 6: UAT Report ``` === UAT REPORT === Milestone: #{N} \| {goal} Branch: iteration/{slug} Scope: {N} features from feature_file_paths[] Mode(s): {automated \| scripted \| exploratory} per feature Results by feature: {feature_id}: {N} scenarios — {passed}/{total} ... Defects: Blockers ({N}): #{list} Majors ({N}): #{list} Minors ({N}): #{list} Test-debt({N}): #{list} Verdict: {CLEAN — proceed to Close \| BLOCKERS FOUND — proceed to Fix & Reintegrate} ================== ``` If 0 blockers: skip Fix & Reintegrate, proceed directly to Close. If 1+ blockers: proceed to Fix & Reintegrate. ## Success Criteria - Scope locked to `feature_file_paths[]` from manifest (no repository-wide test discovery) - Scripted tests run only scenarios matching iteration scope - Precedence rule applied; stale test assertions filed as test-debt, not bugs - Every defect filed with severity; test-debt separated from bugs - UAT report produced with per-feature breakdown and routing verdict ## Agent Saga — medium reasoning model. Executes within declared scope. Applies precedence rule. Files defects. Produces UAT report. Cannot skip assertions, expand scope, or modify test/spec files. ## Rules `do-informative-logging`, `do-follow-commit-convention`
6	TL Fixes Blockers and Regresses	MIN-6	Purpose Team Lead triages the UAT blocker list, invokes BPE-09 (Fix Bug) once per blocker, …	Read the 'MIN-6 TL Fixes Blockers and Regresses' activity from playbook 'Junior Edda' (workflow 'Manage Iteration'). Follow its guidance when assisting me. ## Purpose Team Lead triages the UAT blocker list, invokes BPE-09 (Fix Bug) once per blocker, then sends Saga back for a targeted regression run over the affected scenarios. Loop until the regression verdict is CLEAN. Non-blockers are filed as deferred issues and do not gate close. Entry condition: MIN-05 Saga produced a UAT Report with `Blockers > 0`. If blockers = 0, skip this activity — proceed directly to MIN-07. --- ## Step 1: Triage Blockers Read the UAT Report. For each blocker issue: ```bash gh issue view {bug_number} --json number,title,body,labels ``` Extract: failing scenario, step ID, expected vs actual, affected feature. Group by affected file/feature. Prioritize: fix bugs that unblock the most downstream journey steps first. ## Step 2: Invoke BPE-09 Per Blocker For each blocker, run BPE-09 Fix Bug (Activity 203) as a fresh dr-dobbs subagent (cheap-fast model). The BPE-09 input is the Bug Report filed by Saga in MIN-05. Pass it directly: ``` dr-dobbs — run BPE-09 Fix Bug for bug #{bug_number}. Bug Report: gh issue view {bug_number} --json number,title,body Follow BPE-09 steps exactly: 1. Analyze why existing tests missed the bug. 2. Write a failing test that reproduces it (Red). 3. Implement the minimal correct fix (Green). 4. Full regression: pytest tests/ 5. Commit: fix({scope}): {bug_title} — Fixes #{bug_number} 6. Post NODE_PASS on the bug issue. Scope: do not touch files unrelated to this bug. Do not patch symptoms. ``` Launch as a fresh Task subagent. Never resume a prior worker. On NODE_PASS: ```bash gh issue comment {bug_number} --body "<!-- FIX_COMMITTED -->\nCommit: {sha}\nTest gap: {one-line analysis}\n<!-- /FIX_COMMITTED -->" ``` On NODE_FAIL after worker’s internal BPE-09 retry: dispatch one additional TL-guided fix subagent with a narrower prompt targeting only the failing assertion. If still failing: escalate with `drift-escalated` label and await human decision. ## Step 3: Defer Non-Blockers For each Major and Minor defect from the UAT Report: ```bash gh issue edit {issue_number} --add-label "deferred" gh issue comment {issue_number} --body "Deferred. Non-blocker from iteration {slug}. Fix in next iteration." ``` ## Step 4: Regression UAT (Saga in Regression Mode) After all blocker fixes are committed, invoke Saga as a fresh Task subagent (medium model): ``` Saga — regression run for iteration {slug}. Re-execute only the scenarios / journeys that had failures in the prior UAT report: {affected_scenario_list} Follow the full MIN-05 protocol (survey → execute → classify → report). Produce a verdict: CLEAN or NEW_BLOCKERS_FOUND. ``` CLEAN → proceed to MIN-07 TL Closes Sprint with Lessons and Release. NEW_BLOCKERS_FOUND → loop back to Step 1. Each loop iteration must make net progress (at least one fewer blocker than the prior loop). If the same blocker persists across two fix cycles: escalate. ## Exit Condition Saga regression verdict is CLEAN and no open `blocker`-labelled issues remain on the milestone. ## Success Criteria - Every UAT blocker passed through BPE-09 Fix Bug (test-gap analysis + failing test + fix + regression) - Every fix has a commit where the reproducing test was red before and green after - Full regression suite green after all fixes - Saga regression run returns CLEAN over affected scenarios - Non-blockers labeled `deferred` and removed from milestone gate - Zero open blockers before proceeding to MIN-07 ## Agent Team Lead (Orchestrator) — advanced reasoning model. Triages blockers, assembles BPE-09 prompts, monitors worker results, coordinates regression Saga invocation. dr-dobbs (Worker) — cheap-fast model. Runs BPE-09 Fix Bug per blocker: one bug per invocation, test-first, full regression before NODE_PASS. Saga (Regression UAT) — medium model. Re-runs only affected scenarios from tests/e2e or tests/uat. ## Rules - `do-test-first` (via BPE-09) - `do-not-mock-in-integration-tests` (via BPE-09) - `do-follow-commit-convention` - `do-small-increments`
7	TL Closes Sprint with Lessons and Release	MIN-7	Purpose Final iteration close: verify the full graph execution record, run the TAF health gate, …	Read the 'MIN-7 TL Closes Sprint with Lessons and Release' activity from playbook 'Junior Edda' (workflow 'Manage Iteration'). Follow its guidance when assisting me. ## Purpose Final iteration close: verify the full graph execution record, run the TAF health gate, aggregate lessons learned, apply SAO updates, merge the iteration PR (human gate), tag, create GitHub Release (human gate), and close the milestone. Relationship to Activity 182 (Close Iteration): This activity supersedes Activity 182 'Close Iteration' in Workflow 17, which is deprecated by a companion DROP change in this same PIP submission. Activity 182 predates the TL/worker/Saga model tier separation and lacks the TAF gate, UAT sign-off, and human approval gates introduced here. Predecessor activities in this PIP submission: This activity follows TL Fixes Blockers and Regresses (companion ADD in this PIP, inserted after Activity 183) and TL Integrates and Gates Each Feature (companion ADD in this PIP, inserted after Activity 181 Execute). Entry conditions: - Zero open blocker issues on milestone - Acceptance testing regression verdict: CLEAN (from Activity 183) - Iteration PR open against main --- ## Agent Team Lead — advanced-reasoning AI model (companion ADD Agent in this PIP submission). Operates autonomously throughout this activity except at the two explicit STOP gates (Steps 6 and 7). At those gates the TL presents its work product and waits for human confirmation before taking irreversible actions. When a TAF CRITICAL finding requires a code fix, the TL dispatches a dr-dobbs worker (Agent [9]) and re-runs Validate Test Health (Activity 194) before proceeding. --- ## Step 1: Graph Execution Verification For every closed scenario issue: ```bash gh issue view {N} --json comments \| jq '{ node_pass: [.comments[] \| select(.body \| contains("NODE_PASS"))] \| length, bpe06_node: [.comments[] \| select(.body \| contains("NODE_PASS")) \| select(.body \| contains("BPE-06"))] \| length, build_complete: [.comments[] \| select(.body \| contains("BUILD_COMPLETE"))] \| length, gate_pass: [.comments[] \| select(.body \| contains("GATE_PASS"))] \| length }' ``` All four counts must be >= 1. Any gap: return to Execute (Activity 181) before proceeding. ## Step 2: TAF Health Gate ### 2a. Invoke Validate Test Health (Activity 194) ```bash pytest tests/ --cov=. --cov-report=term-missing make test-at 2>/dev/null \|\| echo "no test-at target" ``` Flag: tests > 10 lines without extraction, mocking violations in integration tests, coverage regression. Produce CRITICAL / WARNING / INFO summary. ### 2b. Invoke Prepare Test Report (Activity 195) - CRITICAL: dispatch dr-dobbs worker (Agent [9]), rerun Activity 194. Blocks merge. - WARNING: file `test-debt` issue, defer - INFO: document in lessons ## Step 3: Lessons Learned Aggregation Create the Iteration Lessons Learned Document (companion ADD Artifact in this PIP submission; see Skill 28 — Lessons Learned Writing): `docs/lessons_learned/ITER-{YYYYMMDD}-{slug}.md` ```markdown --- iteration: ITER-{YYYYMMDD}-{slug} milestone: #{N} — {goal} scenarios_planned: {N} scenarios_delivered: {N} fix_cycles: {N} uat_blockers_found: {N} uat_blockers_resolved: {N} test_debt_found: {N} --- ## Execution Review (per-scenario deviations and drift signals) ## Acceptance Testing (Saga scope, blockers found, fix cycles) ## Test Debt (stale tests filed, coverage gaps) ## Architecture Notes (SAO.md updates applied or deferred) ``` Consumed by: Orient & Validate Scope (Activity 140 in Plan Iteration workflow) as velocity context for the next iteration. ## Step 4: Apply SAO.md Updates Clear and non-controversial → apply to `docs/architecture/SAO.md` now. Requires human judgment → open `sao-update` issue. ## Step 5: Commit Lessons and SAO ```bash git add docs/lessons_learned/ docs/architecture/SAO.md git commit -m "docs(lessons): ITER-{YYYYMMDD}-{slug} — {N}/{N} scenarios, {N} fix cycles" ``` ## Step 6: Human Merge Gate — STOP TL presents work product. Human must say "merge" before proceeding. ``` === MERGE GATE === PR: #{pr_number} — iteration/{slug} → main Delivered: {N} scenarios Acceptance: CLEAN ({N} blockers resolved, {N} deferred) TAF: {CLEAN \| {N} warnings deferred as test-debt} Lessons: docs/lessons_learned/ITER-{YYYYMMDD}-{slug}.md Await: user says "merge" to proceed. ================== ``` On user "merge": ```bash gh pr merge {pr_number} --squash --delete-branch \ --subject "feat(iteration): {slug} — {goal}" ``` ## Step 7: Tag and Release — STOP Assemble the Release Notes Draft (companion ADD Artifact in this PIP submission) and present for human approval: ``` === RELEASE GATE === Tag target: {merge_sha} on main Release tag: ITER-{YYYYMMDD}-{slug} Draft notes: Delivered: {scenario list with issue links} Acceptance: CLEAN Test health: {summary} Deferred: {list or none} Await: user says "release" to proceed. ==================== ``` On user "release": ```bash git checkout main && git pull git log --oneline -1 git tag ITER-{YYYYMMDD}-{slug} {merge_sha} gh release create "ITER-{YYYYMMDD}-{slug}" \ --target {merge_sha} \ --title "Iteration: {goal}" \ --notes "{approved_notes}" ``` ## Step 8: Close Milestone ```bash gh api repos/{owner}/{repo}/milestones/{N} -X PATCH -f state=closed ``` ## Artifacts Produced - Iteration Lessons Learned Document — `docs/lessons_learned/ITER-{YYYYMMDD}-{slug}.md`; consumed by Orient & Validate Scope (Activity 140) - Release Notes Draft — approved by human and published as the GitHub Release body ## Success Criteria - Graph execution record complete per issue - Validate Test Health (Activity 194) CRITICALs resolved; WARNINGs deferred as test-debt - Lessons Learned Document committed - SAO.md updated or sao-update issues filed - User explicitly approved merge; PR squash-merged; branch deleted - Tag points to merge commit on main - User explicitly approved release; GitHub Release created with --target {merge_sha} - Milestone closed ## Skill Skill 28 (Lessons Learned Writing) for Step 3. Skill 32 (GitHub Issue Operations) for Steps 6–8. ## Rules Follow Commit Convention (Rule [6]), Github Issues (Rule [14]), Small Increments (Rule [4])

Activities in Manage Iteration