valent-pipeline 0.19.45 → 0.19.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.19.45",
+  "version": "0.19.47",
   "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/commands/init.js

@@ -2,7 +2,7 @@ import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
 import { existsSync, readFileSync, rmSync } from 'fs';
 import { defaults } from '../lib/config-schema.js';
-import { copyDir, writeFileSafe, appendToGitignore, fileExists } from '../lib/file-ops.js';
+import { copyDir, writeFileSafe, appendToGitignore, writeFrameworkGitignore, fileExists } from '../lib/file-ops.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -225,12 +225,16 @@ export async function init(options = {}) {
   writeFileSafe(claudeSettingsPath, JSON.stringify(claudeSettings, null, 2) + '\n');
   console.log(`  Configured .claude/settings.json (agent teams; pre-approved MCP: ${[...approved].join(', ') || 'none'})`);
 
-  // 9. Update .gitignore
+  // 9. Update .gitignore. The vendored framework is an untracked INSTALL (see writeFrameworkGitignore):
+  // a `.valent-pipeline/.gitignore` keeps the framework code out of git so `upgrade` applies repo-wide
+  // and a reused story branch can never run a stale committed framework (M-52 Finding 1). The
+  // root-.gitignore lines below are belt-and-suspenders for the runtime artifacts.
+  writeFrameworkGitignore(projectRoot);
   appendToGitignore(projectRoot, '.valent-pipeline/pipeline.db');
   appendToGitignore(projectRoot, '.valent-pipeline/pipeline.db-*');
   if (usesChroma) appendToGitignore(projectRoot, '.valent-pipeline/chromadb-data/');
   appendToGitignore(projectRoot, '.valent-pipeline/node_modules/');
-  console.log('  Updated .gitignore');
+  console.log('  Updated .gitignore (framework vendored as an untracked install)');
 
   // 9. Write version file (pkg was read in step 7)
   writeFileSafe(join(projectRoot, '.valent-pipeline', '.valent-version'), pkg.version);

package/src/commands/upgrade.js

@@ -1,7 +1,8 @@
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, copyFileSync, rmSync } from 'fs';
-import { copyDir, writeFileSafe, fileExists, readFile } from '../lib/file-ops.js';
+import { execSync } from 'child_process';
+import { copyDir, writeFileSafe, writeFrameworkGitignore, fileExists, readFile } from '../lib/file-ops.js';
 import { obsoletePaths } from '../lib/obsolete-manifest.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -215,6 +216,26 @@ export async function upgrade(options = {}) {
   writeFileSafe(versionFile, packageVersion);
   console.log(`Updated .valent-pipeline/.valent-version to ${packageVersion}`);
 
+  // Vendor the framework as an untracked INSTALL (M-52 Finding 1): write .valent-pipeline/.gitignore so
+  // the framework lives only in the working tree — `upgrade` then applies repo-wide and a reused story
+  // branch can never run a stale committed framework. If the framework is still git-TRACKED here, print
+  // the one-time untrack transition (we never touch the user's git index ourselves).
+  writeFrameworkGitignore(projectRoot);
+  let frameworkTracked = false;
+  try {
+    execSync('git ls-files --error-unmatch .valent-pipeline/.valent-version', { cwd: projectRoot, stdio: 'ignore' });
+    frameworkTracked = true;
+  } catch { /* not a git repo, or already untracked — no transition needed */ }
+  if (frameworkTracked) {
+    console.log('\n⚠ The vendored framework is still git-TRACKED, so a reused/old story branch will run its');
+    console.log('  STALE committed framework (not this upgrade). To finish the install→untracked transition');
+    console.log('  ONCE, at a clean boundary, run from the repo root:');
+    console.log('    git rm -r --cached --quiet .valent-pipeline && git add .valent-pipeline \\');
+    console.log('      && git commit -m "chore: untrack vendored framework — install not source"');
+    console.log('  (git add re-adds ONLY pipeline-config.yaml + knowledge/ + .gitignore per the new ignore;');
+    console.log('   old branches then need a fresh recut off the transitioned target to pick up the install.)');
+  }
+
   console.log('\nUpgrade complete.');
 }
 

package/src/lib/file-ops.js

@@ -43,6 +43,34 @@ export function appendToGitignore(projectRoot, line) {
   }
 }
 
+// The vendored framework is an INSTALL (re-vendored by `valent-pipeline upgrade`), not source. Keeping
+// it git-tracked meant a REUSED story branch ran whatever framework version it was last committed at
+// (a bug-fix re-run silently executed a stale framework — HARNESS-GAPS 2026-06-19 M-52 Finding 1).
+// This `.valent-pipeline/.gitignore` makes it untracked, so the install lives only in the working tree:
+// gitignored files persist across ALL branch checkouts, one `upgrade` applies repo-wide, and no branch
+// can revert it. `/*` is anchored (direct children only — future-proof to new framework dirs); only
+// project STATE is re-included. KEEP IN SYNC with upgrade.js PROTECTED_FILES.
+export const FRAMEWORK_GITIGNORE = `# valent-pipeline vendored framework — an INSTALL (re-vendored by \`valent-pipeline upgrade\`), not source.
+# Kept UNTRACKED so an upgrade applies repo-wide and a reused story branch never runs a stale committed
+# framework. Only project STATE stays tracked (pipeline-config.yaml, knowledge/).
+/*
+!/.gitignore
+!/pipeline-config.yaml
+!/knowledge/
+`;
+
+/**
+ * Write `.valent-pipeline/.gitignore` so the vendored framework is an untracked install. Idempotent —
+ * rewrites to the canonical content. Returns true if it created or changed the file.
+ */
+export function writeFrameworkGitignore(projectRoot) {
+  const p = join(projectRoot, '.valent-pipeline', '.gitignore');
+  const existing = existsSync(p) ? readFileSync(p, 'utf-8') : null;
+  if (existing === FRAMEWORK_GITIGNORE) return false;
+  writeFileSync(p, FRAMEWORK_GITIGNORE, 'utf-8');
+  return true;
+}
+
 /**
  * Check if a file exists.
  */

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