valent-pipeline 0.19.38 → 0.19.40

package/package.json

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

package/pipeline/orchestrators/claude-code/plan.workflow.js

@@ -30,9 +30,11 @@
  * The return value is shaped to feed straight into sprint.workflow.js:
  *   { sprintId, points_planned, stories: [{ storyId, projectType, profiles }] }
  *
- * args: { stories: [{ storyId, projectType }], sprintId, velocity, lookaheadFactor?, groomBatchSize?, backlogPath?, maxRejectionCycles?, models?, packGate? }
+ * args: { stories: [{ storyId, projectType }], sprintId, velocity, velocityGrowthFactor?, lookaheadFactor?, groomBatchSize?, backlogPath?, maxRejectionCycles?, models?, packGate? }
  *   `velocity` is the current (seeded-SMA) velocity computed by the invoking skill; grooming runs
- *   ahead to `lookaheadFactor × velocity` (default 2) in chunks of `groomBatchSize` (default 10).
+ *   ahead to `lookaheadFactor × velocity` (default 2) in chunks of `groomBatchSize` (default 10). The
+ *   sprint PACKS at `velocity × velocityGrowthFactor` (default 1.1) — a deliberate stretch that pushes
+ *   throughput up over time, governed by the per-story quality gates (see the packVelocity note below).
  *   `models` is the pipeline-config.yaml `models` tier->roles map, passed through by the invoking
  *   skill so per-agent model tiers stay config-driven (editable via `valent configure`). Omit it to
  *   use the baked-in default. See sprint.workflow.js for the full rationale.
@@ -199,6 +201,18 @@ const velocity = a.velocity
 // workflow self-hosts when the args are absent.
 const lookaheadFactor = typeof a.lookaheadFactor === 'number' && a.lookaheadFactor > 0 ? a.lookaheadFactor : 2
 const groomBatchSize = Number.isInteger(a.groomBatchSize) && a.groomBatchSize > 0 ? a.groomBatchSize : 10
+// Velocity STRETCH (2026-06-19): the planner PACKS at `velocity × velocityGrowthFactor`, not the raw
+// trailing SMA. The SMA alone is a lagging, mean-reverting measure with a DOWNWARD ratchet — the packer
+// caps points_shipped at velocity, so any reject/rollover/bug-only sprint pulls the SMA down and nothing
+// ever pushes it back up (velocity can only decay). A flat growth factor applies constant upward pressure
+// while the rigorous per-story gates stay the GOVERNOR: over-reach REJECTS → points_shipped drops → the
+// SMA self-corrects, so throughput climbs only as fast as quality allows and settles at the
+// quality-bounded maximum instead of decaying. Default 1.1 (+10%/sprint); config `sprint.velocity_growth_factor`,
+// passed by the skill. Applied ONLY to the pack — grooming stays on the raw velocity (lookaheadFactor×raw
+// = 2× already covers the 1.1× pack) and the retro's measured `velocity.sma` is left honest (measurement
+// is not the target). round() makes the capacity a whole number (story points are integers).
+const velocityGrowthFactor = typeof a.velocityGrowthFactor === 'number' && a.velocityGrowthFactor > 0 ? a.velocityGrowthFactor : 1.1
+const packVelocity = Math.round(velocity * velocityGrowthFactor)
 const backlogPath = a.backlogPath || 'pipeline-backlog.yaml'
 const maxRejectionCycles = a.maxRejectionCycles ?? 3
 // Pack-time freshness gate config (PUR-001 R-6.2), passed by the skill from pipeline-config.yaml
@@ -648,13 +662,13 @@ if (packGateCommands.length) {
 phase('Pack')
 // Deterministic greedy packing happens in code (src/lib/sprint.js), invoked via the CLI.
 const pack = await agent(
-  `Run exactly: \`node .valent-pipeline/bin/cli.js sprint-pack --velocity ${velocity} --backlog ${backlogPath}\` ` +
+  `Run exactly: \`node .valent-pipeline/bin/cli.js sprint-pack --velocity ${packVelocity} --backlog ${backlogPath}\` ` +
     `in the project root and return its stdout JSON verbatim (fields: sprint_stories, buffer_story_ids, points_planned, remaining_capacity, over_budget).`,
   { label: 'sprint-pack', phase: 'Pack', schema: PACK_SCHEMA, model: modelFor('PACK') },
 )
-log(`packed ${pack.sprint_stories.length} stories (${pack.points_planned} pts); buffer: ${pack.buffer_story_ids.length}`)
+log(`packed ${pack.sprint_stories.length} stories (${pack.points_planned} pts) at capacity ${packVelocity} (velocity ${velocity} × ${velocityGrowthFactor} stretch); buffer: ${pack.buffer_story_ids.length}`)
 if (pack.over_budget) {
-  log(`⚠ sprint ${sprintId} is OVER BUDGET: the highest-priority story exceeds velocity ${velocity} and was planned alone — consider splitting it (${pack.points_planned} pts vs ${velocity} velocity)`)
+  log(`⚠ sprint ${sprintId} is OVER BUDGET: the highest-priority story exceeds the packing capacity ${packVelocity} (velocity ${velocity} × ${velocityGrowthFactor}) and was planned alone — consider splitting it (${pack.points_planned} pts vs ${packVelocity} capacity)`)
 }
 
 // Shaped to feed straight into sprint.workflow.js. Order by `pack.sprint_stories`, NOT by

package/pipeline/orchestrators/claude-code/sprint.workflow.js

@@ -1672,6 +1672,25 @@ async function runShipStep(sid, commandStr, stepPhase) {
       log(`${sid}: ship-story attempt ${attempt}/${shipMergeAttempts} did not land (${res ? 'transient git-runner failure' : 'GIT runner died'}) — retrying the deterministic, idempotent merge`)
     }
   }
+  // Deterministic post-ship verify (M-36/M-37, 2026-06-19): ship-story is a code-owned git merge, but
+  // its result is transcribed by a haiku GIT runner — a transcription slip (or an agent death AFTER the
+  // merge landed) drops `merged:true`, so the loop above reports "did not land" on a merge that ACTUALLY
+  // SUCCEEDED, falsely blocking a shipped story (the git-ship-failed false-positive that stranded 2.20).
+  // Git is the ground truth: when we did NOT confirm a land/conflict/skip, ask `git story-status` — its
+  // `merged` is `isMergedInto` (computed in code, not by the agent); if the branch IS now an ancestor of
+  // the target, the merge LANDED regardless of what the ship runner said → recover to merged:true. A real
+  // conflict (broken out above) and a genuine non-landing (story-status merged:false → real merge-block)
+  // are untouched. The ancestor check cleanly separates the two classes — field-validated by hand on 2.20
+  // (M-38). Only runs on the rare non-landed path, so the happy ship adds zero overhead.
+  const confirmed = !!(res && (res.merged === true || res.skipped === true || res.conflict === true))
+  if (gitFlowEnabled && !confirmed) {
+    const status = await runGitStep(sid,
+      [`node .valent-pipeline/bin/cli.js git story-status --story ${sid}${gitFlags}`], 'merge-verify', stepPhase)
+    if (status && status.merged === true) {
+      log(`${sid}: ship-story runner reported no-land but git story-status confirms the branch IS merged into the target — recovering to merged:true (transcription false-failure, NOT a real merge-block)`)
+      return { ...(res || {}), merged: true, recoveredByVerify: true }
+    }
+  }
   return res
 }
 

package/skills/valent-run-epic-workflow/SKILL.md

@@ -149,7 +149,7 @@ Workflow({
       ...resolved.groomedBuffer,
     ],
     sprintId: '{epic_id}-sprint-{n}', velocity: {computed seeded-SMA velocity, see above},
-    lookaheadFactor: {sprint.groom_lookahead_factor or 2}, groomBatchSize: {sprint.max_groom_batch_size or 10},
+    lookaheadFactor: {sprint.groom_lookahead_factor or 2}, groomBatchSize: {sprint.max_groom_batch_size or 10}, velocityGrowthFactor: {sprint.velocity_growth_factor or 1.1},
     maxRejectionCycles: {quality.max_rejection_cycles or 3}, backlogPath: '{backlog_path}',
     knowledge: { mode: <config.knowledge.mode or 'sqlite'>, curatedPath: <config.knowledge.curated_files_path or 'knowledge/curated'> },
     models: <config.models or omit>, reasoning: <config.reasoning or omit>, packGate: <config.pack_gate or omit>,

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

@@ -149,7 +149,7 @@ Workflow({
       ...resolved.groomedBuffer,
     ],
     sprintId: 'project-sprint-{n}', velocity: {computed seeded-SMA velocity, see above},
-    lookaheadFactor: {sprint.groom_lookahead_factor or 2}, groomBatchSize: {sprint.max_groom_batch_size or 10},
+    lookaheadFactor: {sprint.groom_lookahead_factor or 2}, groomBatchSize: {sprint.max_groom_batch_size or 10}, velocityGrowthFactor: {sprint.velocity_growth_factor or 1.1},
     maxRejectionCycles: {quality.max_rejection_cycles or 3}, backlogPath: '{backlog_path}',
     knowledge: { mode: <config.knowledge.mode or 'sqlite'>, curatedPath: <config.knowledge.curated_files_path or 'knowledge/curated'> },
     models: <config.models or omit>, reasoning: <config.reasoning or omit>, packGate: <config.pack_gate or omit>,

package/src/commands/init.js

@@ -575,6 +575,10 @@ sprint:
   groom_lookahead_factor: ${config.sprint?.groom_lookahead_factor ?? 2}
   # Trailing window (sprints) for the velocity simple moving average, seeded with initial_velocity_points.
   velocity_sma_window: ${config.sprint?.velocity_sma_window ?? 3}
+  # Velocity STRETCH: the planner packs at velocity_sma × this factor (not the raw SMA), so throughput
+  # climbs over time instead of decaying; the per-story quality gates govern it (over-reach rejects →
+  # the SMA self-corrects). 1.0 disables the stretch.
+  velocity_growth_factor: ${config.sprint?.velocity_growth_factor ?? 1.1}
 
 orchestration:
   recommended_context_window: "${config.orchestration?.recommended_context_window || '200k'}"

package/src/commands/upgrade.js

@@ -135,7 +135,7 @@ export async function upgrade(options = {}) {
     let configContent = readFile(configPath);
     if (!configContent.includes('sprint:')) {
       // Insert sprint section before orchestration (or at end if orchestration not found)
-      const sprintBlock = `\nsprint:\n  duration_minutes: 480\n  initial_velocity_points: 60\n  estimation_model: "calibrated"\n  auto_plan: true\n  fibonacci_scale: [1, 2, 3, 5, 8, 13, 21]\n  max_groom_batch_size: 10\n  groom_lookahead_factor: 2\n  velocity_sma_window: 3\n`;
+      const sprintBlock = `\nsprint:\n  duration_minutes: 480\n  initial_velocity_points: 60\n  estimation_model: "calibrated"\n  auto_plan: true\n  fibonacci_scale: [1, 2, 3, 5, 8, 13, 21]\n  max_groom_batch_size: 10\n  groom_lookahead_factor: 2\n  velocity_sma_window: 3\n  velocity_growth_factor: 1.1\n`;
       const insertPoint = configContent.indexOf('\norchestration:');
       if (insertPoint !== -1) {
         configContent = configContent.slice(0, insertPoint) + sprintBlock + configContent.slice(insertPoint);

package/src/lib/config-schema.js

@@ -288,6 +288,7 @@ export function validateConfig(config) {
       max_groom_batch_size: 'number',
       groom_lookahead_factor: 'number',
       velocity_sma_window: 'number',
+      velocity_growth_factor: 'number',
     };
     for (const [field, type] of Object.entries(sprintFields)) {
       if (config.sprint[field] !== undefined && typeof config.sprint[field] !== type) {
@@ -562,6 +563,13 @@ export const defaults = {
     // Trailing window (in sprints) for the velocity simple moving average. The SMA is seeded with
     // initial_velocity_points so sprints 1..velocity_sma_window ramp smoothly before the seed ages out.
     velocity_sma_window: 3,
+    // Velocity STRETCH multiplier. The planner PACKS at `velocity_sma × velocity_growth_factor` (not the
+    // raw SMA), applying constant upward pressure so throughput climbs over time instead of decaying — a
+    // plain SMA is lagging + mean-reverting and only ratchets DOWN (the packer caps shipped points at
+    // velocity, so any reject/rollover pulls it down and nothing pushes it back up). The per-story quality
+    // gates are the governor: over-reach rejects → shipped points drop → the SMA self-corrects, so velocity
+    // rises only as fast as quality holds and settles at the quality-bounded max. 1.0 disables the stretch.
+    velocity_growth_factor: 1.1,
   },
   orchestration: {
     recommended_context_window: '200k',