valent-pipeline 0.19.46 → 0.19.48

package/package.json

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

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

@@ -661,11 +661,44 @@ if (packGateCommands.length) {
 
 phase('Pack')
 // Deterministic greedy packing happens in code (src/lib/sprint.js), invoked via the CLI.
-const pack = await agent(
+let pack = await agent(
   `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') },
 )
+// Pack-transcription integrity gate (M-51). The agent above transcribes the sprint-pack CLI's stdout
+// (this sandboxed Workflow script can't run a CLI itself). That transcription has corrupted the result
+// twice in the field — an empty sprint_stories paired with a non-zero points_planned (19, then 9) —
+// making the planner think the deterministic packer deadlocked and hand-launch a story over budget. It
+// never does: points_planned is the SUM of the packed stories' points and the anti-stall guard
+// force-adds the top story when nothing fits (src/lib/sprint.js → packSprint), so an empty pack ALWAYS
+// reports 0. A non-zero total with no stories is an impossible packer output = a dropped-stories
+// transcription. Re-run once verbatim; a second failure is a hard stop (a phantom-empty sprint silently
+// strands all ready work — far worse than a loud planning error). Mirrors
+// src/lib/sprint.js#packTranscriptionIssue (the unit-tested canonical check), kept in sync by hand
+// because a Workflow script cannot import it.
+const packInconsistent = (p) => {
+  if (!p || !Array.isArray(p.sprint_stories) || typeof p.points_planned !== 'number') {
+    return 'pack result is malformed (sprint_stories must be an array, points_planned a number)'
+  }
+  if (p.sprint_stories.length === 0 && p.points_planned !== 0) {
+    return `empty sprint_stories but points_planned=${p.points_planned} — an empty pack sums to 0, so the transcription dropped the packed stories`
+  }
+  return null
+}
+let packIssue = packInconsistent(pack)
+if (packIssue) {
+  log(`⚠ sprint-pack transcription inconsistent (${packIssue}) — re-running the CLI verbatim`)
+  pack = await agent(
+    `Your previous answer was INVALID: ${packIssue}. Re-run EXACTLY: \`node .valent-pipeline/bin/cli.js sprint-pack --velocity ${packVelocity} --backlog ${backlogPath}\` ` +
+      `in the project root and copy its stdout JSON byte-for-byte — do NOT summarize, re-order, drop stories, or alter any number. Fields: sprint_stories, buffer_story_ids, points_planned, remaining_capacity, over_budget.`,
+    { label: 'sprint-pack-retry', phase: 'Pack', schema: PACK_SCHEMA, model: modelFor('PACK') },
+  )
+  packIssue = packInconsistent(pack)
+  if (packIssue) {
+    throw new Error(`sprint-pack transcription stayed inconsistent after a verbatim re-run: ${packIssue}. Raw: ${JSON.stringify(pack)}. The deterministic packer (src/lib/sprint.js) never emits this — re-run plan or inspect the CLI output directly.`)
+  }
+}
 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 the packing capacity ${packVelocity} (velocity ${velocity} × ${velocityGrowthFactor}) and was planned alone — consider splitting it (${pack.points_planned} pts vs ${packVelocity} capacity)`)

package/src/lib/git-flow.js

@@ -524,6 +524,10 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
   let refreshedFromTarget = false;
   let refreshConflict = false;
   if (basedOnStory && branchExists(root, target) && !isMergedInto(root, target, branch)) {
+    // Capture whether the vendored install is present BEFORE the sync, so the hazard guard below fires
+    // ONLY when the merge actually REMOVED it — not when a repo simply never had a materialized install
+    // (e.g. a bare test fixture), which must refresh normally.
+    const hadFrameworkInstall = existsSync(join(root, '.valent-pipeline', 'bin', 'cli.js'));
     try {
       git(root, ['merge', '--no-ff', '-m',
         buildCommitMessage({ storyId: story, phase: 'sync', summary: `sync ${target} into ${branch} (inherit shared state from a behind base)` }), target]);
@@ -532,6 +536,24 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
       if (mergeInProgress(root)) git(root, ['merge', '--abort']);
       refreshConflict = true;
     }
+    // M-52 transition hazard: when `target` UNTRACKS the vendored framework (the post-untrack install
+    // model) while THIS branch still TRACKS it (a pre-untrack branch), the merge above applied target's
+    // index-deletion to the WORKING TREE and removed the on-disk install — `.valent-pipeline/bin/cli.js`
+    // is gone, so the next `node .valent-pipeline/bin/cli.js` call would fail mid-sprint. Such a branch
+    // cannot be refreshed in place (keeping the merge loses the install; reverting it restores a STALE
+    // framework — the very thing untracking fixed), so undo the sync and surface it like a conflict: the
+    // caller must recut the branch FRESH off the untracked target. (The worktree create-path self-heals
+    // via setupWorktree's re-materialize; this serial path has no such restore.)
+    if (refreshedFromTarget && hadFrameworkInstall && !existsSync(join(root, '.valent-pipeline', 'bin', 'cli.js'))) {
+      git(root, ['reset', '--hard', 'ORIG_HEAD']);
+      refreshedFromTarget = false;
+      refreshConflict = true;
+      console.error(
+        `git-flow: sync of ${target} into ${branch} would DELETE the vendored framework install ` +
+        `(${target} untracks .valent-pipeline/ but ${branch} still tracks it — M-52 untrack transition). ` +
+        `Skipped the sync; ${branch} left at its base — recut it FRESH off ${target} instead of --from-story.`,
+      );
+    }
   }
   writeFlowRecord(root, story, {
     schema: 1,

package/src/lib/sprint.js

@@ -281,6 +281,53 @@ export function packSprint(stories, velocity, opts = {}) {
   };
 }
 
+/**
+ * Pack-transcription integrity gate (M-51). The PACK workflow step can't run a CLI itself (a
+ * Workflow script has no fs/CLI access), so an LLM agent runs `sprint-pack` and transcribes its
+ * stdout JSON. That transcription has corrupted the result twice in the field — an empty
+ * `sprint_stories` paired with a non-zero `points_planned` (19, then 9) — which made the planner
+ * believe the deterministic packer deadlocked and hand-launch a story over budget. It never did:
+ * `points_planned` is DEFINED as the sum of the packed stories' points (see packSprint), and the
+ * anti-stall guard force-adds the top story when nothing fits, so an empty pack ALWAYS reports 0.
+ * This checks those packer INVARIANTS against a (possibly transcribed) result and returns a
+ * human-readable reason when one is violated, else null — so the caller can re-run the transcription
+ * before trusting it. Invariant-based, so a legitimately empty pack (no packable work → 0 points)
+ * passes; only an internally inconsistent result fails (no false positives).
+ *
+ * NOTE: the PLAN orchestrator (plan.workflow.js) is a sandboxed Workflow script that cannot import
+ * this module, so it inlines the empty⟺0 check; keep the two in sync. This exported helper is the
+ * canonical, unit-tested spec of the invariant (and is reusable by any non-sandboxed caller).
+ *
+ * @param {{sprint_stories?: string[], points_planned?: number}} pack  a pack result (CLI or transcribed)
+ * @param {{pointsById?: Map<string, number>}} [opts]  known story→points; when EVERY packed id is
+ *   present the exact sum is asserted too (skipped otherwise — a buffer story's points may be out of
+ *   the caller's context, and a partial sum would false-flag).
+ * @returns {string|null}  why the result violates a packer invariant, or null if consistent
+ */
+export function packTranscriptionIssue(pack, opts = {}) {
+  if (!pack || typeof pack !== 'object') return 'pack result is not an object';
+  const ids = pack.sprint_stories;
+  if (!Array.isArray(ids)) return 'sprint_stories is not an array';
+  const pts = pack.points_planned;
+  if (typeof pts !== 'number' || !Number.isFinite(pts) || pts < 0) {
+    return `points_planned must be a non-negative number, got ${JSON.stringify(pts)}`;
+  }
+  // Invariant: points_planned is a SUM over the packed stories → an empty pack reports exactly 0.
+  // (The reverse — non-empty with 0 points — is NOT flagged: a 0-point story is conceivable.)
+  if (ids.length === 0 && pts !== 0) {
+    return `empty sprint_stories but points_planned=${pts} — an empty pack sums to 0, so the transcription dropped the packed stories`;
+  }
+  // Invariant (full knowledge only): the total equals the recomputed sum of the packed stories.
+  const { pointsById } = opts;
+  if (pointsById instanceof Map && ids.length > 0 && ids.every((id) => pointsById.has(id))) {
+    const sum = ids.reduce((acc, id) => acc + (Number(pointsById.get(id)) || 0), 0);
+    if (sum !== pts) {
+      return `points_planned=${pts} but the packed stories sum to ${sum} (${ids.join(', ')}) — the transcription altered the total`;
+    }
+  }
+  return null;
+}
+
 /**
  * Cross-epic candidate eligibility for the next sprint — which pending backlog items can be
  * groomed now. A deterministic replacement for the hand-run "collect pending stories whose