valent-pipeline 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "v3 multi-agent AI pipeline for software development lifecycle",
   "type": "module",
   "bin": {

package/pipeline/prompts/lead.md

@@ -451,12 +451,16 @@ Tear down all per-story teammates. Send `shutdown_request` to each individually.
 - Update `pipeline-state.json`
 - **Update `{backlog_path}`:**
   1. Set the current item's `status` to `shipped` and add `shipped_at` date
-  2. If JUDGE G2 issued a conditional ship with bugs, add each bug as a new `bug` type entry in the backlog with:
+  2. If JUDGE G2 issued a conditional ship with bugs (P2-P3), add each bug as a new `bug` type entry in the backlog with:
      - `status: pending`
      - `priority`: one above the next pending story (bugs get worked before new stories by default)
      - `severity`, `source_story`, `affects`, `description`, `file_ref` from the G2 decision and QA-B bug report
-  3. Add the bug IDs to the shipped story's `conditional_bugs` list
-  4. For any pending stories whose `blocked_by_bugs` referenced bugs that are now `shipped`, those blockers are resolved — the story becomes unblocked if all other dependencies are also met
+  3. Add P4 bugs from `{story_output_dir}/bugs.md` to the backlog at the **lowest priority** (highest priority number). These are worked only when no other stories or bugs are unblocked — the pipeline always has something to do.
+     - `status: pending`
+     - `priority`: max existing priority + 1 (per bug, incrementing)
+     - `severity: P4`, `source_story`, `description`, `file_ref` from QA-B bug report
+  4. Add the conditional bug IDs (P2-P3) to the shipped story's `conditional_bugs` list. P4 bugs are not conditional — they don't block anything.
+  5. For any pending stories whose `blocked_by_bugs` referenced bugs that are now `shipped`, those blockers are resolved — the story becomes unblocked if all other dependencies are also met
 
 ### Step 5b: Write Epic Progress Checkpoint
 

package/skills/valent-run-project/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: valent-run-project
+description: 'Run all stories across all epics, ordered by dependencies, until everything ships or is blocked. Use when the user says "run project", "run all stories", "valent run project", or "execute project"'
+---
+
+# valent-run-project
+
+Run every pending story in the backlog, across all epics, in dependency order. Stories are picked by priority with cross-epic dependency resolution — a story from Epic B can run before Epic A finishes if its dependencies are met. The loop continues until all stories are shipped, blocked, or cancelled.
+
+## Context Window Advisory
+
+Use the standard 200k context window. Auto-compression fires every 2-3 stories. The PostCompact hook re-injects state from disk. All state is read from disk at loop top — never trust in-context memory.
+
+## Execution Steps
+
+### Step 1: Load Pipeline Config
+
+Read and follow `.valent-pipeline/steps/orchestration/load-pipeline-config.md`.
+
+### Step 2: Build Cross-Epic Dependency Map
+
+Read `{backlog_path}`. Load ALL items (not filtered by epic).
+
+**Build the dependency graph:**
+1. For each item, record its `depends_on` list and `blocked_by_bugs` list
+2. Identify cross-epic dependencies (story in Epic A depends on story in Epic B)
+3. Validate: check for circular dependencies. If found, report to user and stop.
+
+**Present the execution plan:**
+
+```
+Project: {N} stories across {M} epics
+  Shipped: {count}
+  Pending: {count}
+  Blocked: {count}
+
+Execution order (by dependency + priority):
+  1. {STORY-ID} (Epic: {epic}) — no dependencies
+  2. {STORY-ID} (Epic: {epic}) — depends on: {ids}
+  3. {STORY-ID} (Epic: {epic}) — depends on: {ids}
+  ...
+
+Cross-epic dependencies:
+  - {STORY-ID} (Epic B) depends on {STORY-ID} (Epic A)
+  ...
+```
+
+Ask: "Run all {N} pending stories in this order? (Stories will be picked dynamically as dependencies resolve.)"
+
+### Step 3: Initialize or Resume Project Progress
+
+Read `{epic_progress_path}`.
+
+**If the file exists and `epic_id` is `"project"`:** This is a **resume**. Display prior progress. Confirm: "Resuming project run — {completed} stories done, {remaining} remaining. Continue?"
+
+**If the file does not exist or `epic_id` differs:** Create initial progress file:
+
+```markdown
+---
+epic_id: "project"
+stories_completed: []
+stories_remaining: [{all pending story IDs from backlog}]
+current_story: null
+stories_since_retro: 0
+total_completed: 0
+last_updated: {ISO-8601}
+---
+
+## Story Outcomes (compact — max 2 lines per story)
+```
+
+### Step 4: Story Loop
+
+Loop until all stories are shipped, blocked, or cancelled.
+
+#### 4a. Re-read State from Disk
+
+**ALWAYS** read `{epic_progress_path}` and `{backlog_path}` from disk at the top of each iteration. **NEVER** rely on in-context memory. Context compression may have fired — disk is the source of truth.
+
+#### 4b. Resolve Next Story (Cross-Epic)
+
+Read and follow `.valent-pipeline/steps/orchestration/resolve-next-work-item.md`.
+
+**Do NOT set `{epic_filter}`.** Scan the entire backlog across all epics. The first `pending` item whose:
+- `depends_on` are all `shipped`
+- `blocked_by_bugs` are all `shipped` or `cancelled`
+
+...is the next work item, regardless of which epic it belongs to.
+
+**If no unblocked stories remain:** Check why.
+- If ALL remaining stories are `shipped` or `cancelled` → project complete, go to Step 5
+- If remaining stories are `blocked` or `blocked-on-user` → report the blocked stories and their blockers to the user, go to Step 5
+- If remaining stories are `pending` but all have unmet `depends_on` → circular dependency or missing prerequisite. Report and stop.
+
+#### 4c. Resolve Story Path
+
+Read and follow `.valent-pipeline/steps/orchestration/resolve-story-path.md`.
+
+#### 4d. Validate Story Inputs
+
+Read and follow `.valent-pipeline/steps/orchestration/validate-story-inputs.md`.
+
+On validation failure: mark story `blocked-on-user` in backlog, update progress file, continue to next iteration (Step 4a). Do not stop the project — pick the next unblocked story.
+
+#### 4e. Load Agents Manifest
+
+Read and follow `.valent-pipeline/steps/orchestration/load-agents-manifest.md`.
+
+#### 4f. Adopt Lead and Run Story
+
+Read and follow `.valent-pipeline/steps/orchestration/adopt-lead-and-create-team.md`.
+
+Set `{is_epic_run}` = true. Set `{epic_id}` = `"project"`.
+
+Enter monitoring mode — follow `.valent-pipeline/prompts/lead.md` through story completion.
+
+#### 4g. Update Progress
+
+After the story ships (or is cancelled/blocked), update `{epic_progress_path}`:
+- Move the story from `stories_remaining` to `stories_completed`
+- Add a compact outcome line: `{STORY-ID} ({epic}): SHIPPED {date}. {one-line summary}. {test counts}. {bug count}.`
+- Update `total_completed`, `stories_since_retro`, `last_updated`
+- **FIFO at 80 lines:** When the outcomes section exceeds 80 lines, remove the oldest outcome at the top to make room for the new one at the bottom. Recent context is most valuable after compression; older outcomes live in individual story reports.
+
+#### 4h. Update Backlog
+
+Read and follow `.valent-pipeline/steps/orchestration/update-backlog-status.md`.
+
+**After updating:** Re-check if any previously blocked stories are now unblocked (their `depends_on` or `blocked_by_bugs` may have been resolved by the story that just shipped). These become eligible for the next iteration.
+
+#### 4i. Retrospective Check (BLOCKING)
+
+If `stories_since_retro >= {retrospective_every_n_stories}`:
+1. Spawn the Retrospective Agent with the last N story reports
+2. **Wait for the retrospective to complete** (blocking)
+3. Reset `stories_since_retro` to 0
+4. Update `pipeline-state.json`
+
+#### 4j. Continue Loop
+
+Return to Step 4a.
+
+### Step 5: Project Complete
+
+When all stories are shipped (or remaining are all blocked/cancelled):
+
+#### 5a. Write Project Report
+
+Write `project-report.md` adjacent to `{epic_progress_path}`:
+
+```markdown
+# Project Report
+
+## Summary
+- Total stories: {N}
+- Shipped: {count}
+- Blocked: {count} {list with reasons}
+- Cancelled: {count}
+- Bugs filed: {total across all stories}
+- Retrospectives run: {count}
+
+## Per-Epic Summary
+### {Epic ID}
+- Stories: {shipped}/{total}
+- {one-line per story from progress file}
+
+### {Epic ID}
+- ...
+
+## Blocked Stories
+{For each blocked story: ID, epic, what it's blocked on, and recommended action}
+
+## Cross-Epic Bugs
+{Conditional bugs from shipped stories that are still pending}
+```
+
+#### 5b. Report to User
+
+Present the project completion summary. Highlight:
+- Any blocked stories and what they need
+- Any pending bugs from conditional ships
+- Retrospective summary if any ran
+
+## Error Recovery
+
+### Mid-Story Failure
+If a story fails (circuit breaker exhausted, user cancels): mark it `cancelled` in the backlog, update progress, **continue to the next unblocked story**. A single story failure does not stop the project. Stories that depend on the cancelled story become blocked — report them but keep working on anything else that's unblocked.
+
+### Context Compression
+Expected. The PostCompact hook re-injects state files. Step 4a re-reads everything from disk.
+
+### Full Conversation Reset
+User re-runs `/valent-run-project`. Step 3 detects existing progress file with `epic_id: "project"` and resumes. Shipped stories are not re-run.
+
+### All Stories Blocked
+If the loop finds no unblocked stories but pending stories remain:
+1. List each blocked story with its unmet dependencies
+2. Ask the user: "All remaining stories are blocked. Options: (1) Fix blockers and re-run, (2) Cancel blocked stories, (3) Override a dependency"
+3. Do NOT loop forever waiting for blockers to resolve
+
+## Notes
+
+- You are the Lead for each story. The lead prompt (`.valent-pipeline/prompts/lead.md`) is YOUR operating manual.
+- **Do NOT read agent output files.** Quality is JUDGE gates' and CRITIC's job.
+- **Always read from disk, never from memory** at the top of each loop iteration.
+- **Progress file is the crash recovery substrate.** FIFO queue — cap outcomes at 80 lines, evict oldest.
+- **Retrospectives run BLOCKING.**
+- **Shutdown must be sent individually, not broadcast.**
+- Correction directives may not exist yet for new pipelines — proceed without them.
+
+### Knowledge Agent Persistence
+
+Same as `valent-run-epic`: Knowledge persists across all stories in the project run.
+
+**Team lifecycle:**
+- Use team name `valent-project` for the entire run.
+- At story teardown: shut down all per-story teammates EXCEPT Knowledge.
+- At project completion (Step 5): tear down Knowledge, then `TeamDelete`.
+- First story spawns Knowledge normally. All subsequent stories use `[STORY-RESET]`.