valent-pipeline 0.19.16 → 0.19.22

package/package.json

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

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

@@ -226,6 +226,7 @@ const JUDGE_DECISION_SCHEMA = {
           description: { type: 'string' },
           file_ref: { type: 'string' },               // e.g. bugs.md#BUG-002
           category: { type: 'string' },               // e.g. pre-existing | minor
+          preExisting: { type: 'boolean' },           // mirrors bugs.md valent:bugs preExisting — a pre-existing carried bug is NON-blocking (the ship clamp's isPre must match crosscheck.js: preExisting===true || category==='pre-existing')
         },
       },
     },
@@ -1568,9 +1569,31 @@ async function runIntegrationGate(shipped) {
 // STATIC/EVIDENCE/BACKLOG). Returns the LAST command's JSON line, or null if the agent died;
 // callers that depend on the outcome (ship-story) must check `merged === true` explicitly.
 // No-op (returns null without spawning) when the git flow is disabled.
+//
+// The GIT runner is a cheap (haiku) agent that TRANSCRIBES the CLI's JSON line into a typed-free
+// StructuredOutput ({additionalProperties:true}). On Windows/haiku it routinely STRINGIFIES the
+// values — `merged:true` → `merged:"true"`, `changedFiles:[...]` → `changedFiles:"[...]"` — which
+// silently broke every strict `ship.merged === true` / `.conflict === true` check downstream and
+// reported `git-ship-failed` on merges that ACTUALLY LANDED (false reject; root of repeated manual
+// ship reconciles). Git is deterministic — the CLI's real types are the truth; coerce the
+// transcription back. "true"/"false" strings → booleans (no git result field is legitimately the
+// string "true"/"false"); a string that is a JSON array → the array (changedFiles/conflictFiles/files).
+function normalizeGitResult(r) {
+  if (!r || typeof r !== 'object' || Array.isArray(r)) return r
+  const out = {}
+  for (const [k, v] of Object.entries(r)) {
+    if (v === 'true') out[k] = true
+    else if (v === 'false') out[k] = false
+    else if (typeof v === 'string' && /^\s*\[[\s\S]*\]\s*$/.test(v)) {
+      try { out[k] = JSON.parse(v) } catch { out[k] = v }
+    } else out[k] = v
+  }
+  return out
+}
+
 async function runGitStep(sid, commands, label, stepPhase, dirPhrase = 'the project root') {
   if (!gitFlowEnabled) return null
-  const result = await agent(
+  const result = normalizeGitResult(await agent(
     [
       `You are **GIT**, the deterministic git-flow runner for story ${sid} in the valent-pipeline.`,
       `Run each command below from ${dirPhrase}, in order, exactly as written. Do NOT compose any`,
@@ -1584,7 +1607,7 @@ async function runGitStep(sid, commands, label, stepPhase, dirPhrase = 'the proj
       `return its JSON line (it carries ok:false and the failure detail).`,
     ].join('\n'),
     { label: `git:${label}:${sid}`, phase: stepPhase, schema: { type: 'object', additionalProperties: true }, model: modelFor('GIT') },
-  )
+  ))
   if (result && result.skipped === true) log(`${sid}/GIT: ${label} skipped — not a git repository`)
   return result
 }
@@ -2712,7 +2735,7 @@ async function runStory(story) {
         `\`evidence assert\` + \`trace check\` (gate verdict: ${evGate.verdict}${evGate.escalated ? ', escalated after the rework cap' : ''}${evGate.advisory ? ', advisory' : ''}). ` +
         `Read the NEWEST JSON under \`stories/${sid}/evidence/asserts/\`` +
         `${evGate.verdictPath ? ` (the gate reported \`${evGate.verdictPath}\`)` : ''} and TRANSCRIBE testsPassed/testsFailed/openP1toP3 ` +
-        `from its counts (openP1toP3 from the \`valent:bugs\` block in bugs.md) — do NOT count from execution-report.md prose. ` +
+        `from its counts (openP1toP3 = bugs in the \`valent:bugs\` block of bugs.md with status open/fix-in-progress AND priority P1/P2/P3, EXCLUDING any with \`preExisting: true\` or \`category: pre-existing\` — baselined pre-existing bugs are non-blocking and the cross-check counts them separately, so including them here produces a verdict-integrity mismatch and refuses the ship) — do NOT count from execution-report.md prose. ` +
         `Set evidenceVerdict to the assert verdict and gitSha to the evidence run's SHA. Your job on numbers is ANOMALY ` +
         `DETECTION: FLAG as a discrepancy any claim in execution-report.md / traceability-matrix.md / bugs.md that the ` +
         `evidence JSON does not support (counts, suites, commands, SHA, pre-existing exclusions).` +
@@ -2775,8 +2798,12 @@ async function runStory(story) {
           'resolved, every AC covered, no assertion weakening) but bugs.md still has open NON-BLOCKING bugs: ' +
           'open P4s and pre-existing failures (file-bugs.md §8b). The story ships, but every such bug MUST ' +
           'carry to the backlog. List each one in `bugs` (priority, severity, affects, description, ' +
-          'file_ref like bugs.md#BUG-00n, category). Never carry a blocking P1-P3 story bug — that is a REJECT ' +
-          '(enforced in code: a ship carrying a non-pre-existing P1-P3 bug is mechanically voided to REJECT).\n' +
+          'file_ref like bugs.md#BUG-00n, category, and `preExisting`). Set `preExisting: true` on any carried ' +
+          'bug that is pre-existing in bugs.md (preExisting:true or category pre-existing) — KEEP its real ' +
+          'functional category (e.g. integration); the ship clamp uses `preExisting === true || category === ' +
+          '"pre-existing"` (matching the cross-check) to recognize it as non-blocking. Never carry a blocking ' +
+          'P1-P3 story bug — that is a REJECT (enforced in code: a ship carrying a non-pre-existing P1-P3 bug ' +
+          'is mechanically voided to REJECT).\n' +
           '  • REJECT (verdict "fail") — any blocking evidence item fails.\n' +
           'If the Evidence gate is RED after its rework budget, a SHIP additionally requires `flags` to include ' +
           '"pre-existing-only-failures" — your explicit, auditable assertion that EVERY remaining failure is ' +
@@ -2801,8 +2828,8 @@ async function runStory(story) {
           model: modelFor('JUDGE-DECIDE'),
           returnContract:
             'Return ONLY { schema:1, agent:"judge", story, verdict:"pass"|"ship-with-bugs"|"fail", ' +
-            'highFindingsOpen, bugs:[{id,priority,severity,affects,description,file_ref,category}], flags } ' +
-            'as JSON. `bugs` is [] unless verdict is "ship-with-bugs".',
+            'highFindingsOpen, bugs:[{id,priority,severity,affects,description,file_ref,category,preExisting}], flags } ' +
+            'as JSON. `bugs` is [] unless verdict is "ship-with-bugs"; set preExisting:true on carried pre-existing bugs.',
         }), `JUDGE ship decision for ${sid}`),
       'JUDGE',
     )
@@ -2861,8 +2888,13 @@ async function runStory(story) {
     // one judged path the doctrine allows). Coerced to REJECT — the normal disposition machinery
     // (file bugs, revalidate or escalate) takes it from there.
     const shipping = decision.verdict === 'pass' || decision.verdict === 'ship-with-bugs'
+    // isPre MUST match crosscheck.js (`preExisting === true || category === 'pre-existing'`): a bug
+    // can be pre-existing (non-blocking) AND keep its functional category (e.g. integration). Checking
+    // only `category !== 'pre-existing'` voided ship-with-bugs to REJECT for baselined pre-existing
+    // P3s whose category was their real area (story 1.2 BUG-002/003 — diverged from the cross-check).
+    const isPreCarried = (b) => b && (b.preExisting === true || b.category === 'pre-existing')
     const blockingCarried = (decision.bugs || []).filter(
-      (b) => b && ['P1', 'P2', 'P3'].includes(b.priority) && b.category !== 'pre-existing',
+      (b) => b && ['P1', 'P2', 'P3'].includes(b.priority) && !isPreCarried(b),
     )
     let clamp = null
     if (shipping && blockingCarried.length) {

package/src/lib/crosscheck.js

@@ -55,11 +55,25 @@ export function crosscheckVerdict({ reported = null, bugsBlock = null, assertVer
   }
 
   const claim = (field) => reported && reported[field] !== undefined && reported[field] !== null;
+  // Counts of BAD things (failures, open blocking bugs): a self-report HIGHER than the machine
+  // recount is the SAFE, conservative direction — the gate was harder on itself than reality (e.g. a
+  // JUDGE that counted a pre-existing, baseline-excluded failure as testsFailed/openP1toP3). That is
+  // NOT the integrity breach this module exists to catch — a gate HIDING failures/bugs to sneak a
+  // ship is claimed < actual — and refusing it stranded genuinely shippable stories. So an
+  // over-report on these fields reconciles to the authoritative recount with a warning; an
+  // under-report stays a hard mismatch. (Prompt tightening alone did not hold — the LLM still
+  // over-counts; this is the mechanical backstop.) Good-thing counts (testsPassed) and exact-match
+  // fields keep strict equality, where over-claiming IS the unsafe direction.
+  const SAFE_IF_OVER_REPORTED = new Set(['testsFailed', 'openP1toP3']);
   const compare = (field, actual) => {
     recounted[field] = actual;
-    if (claim(field) && reported[field] !== actual) {
-      mismatches.push({ field, claimed: reported[field], actual });
+    if (!claim(field) || reported[field] === actual) return;
+    if (SAFE_IF_OVER_REPORTED.has(field) && typeof reported[field] === 'number'
+        && typeof actual === 'number' && reported[field] > actual) {
+      warnings.push(`${field}: self-reported ${reported[field]} but artifacts show ${actual} — over-report (safe, conservative direction), reconciled to the recount`);
+      return;
     }
+    mismatches.push({ field, claimed: reported[field], actual });
   };
 
   // Test counts — from the assert verdict (machine-derived twice over).

package/src/lib/git-flow.js

@@ -171,6 +171,12 @@ const STATE_EXCLUDE_PATTERNS = [
   'stories/*/evidence/pins.jsonl',
   'stories/*/evidence/resolved-graph.json',
   'stories/*/evidence/stage-results.json',
+  // The run pointer the orchestrator + skills rewrite around every Workflow call (/valent-resume
+  // reads it off disk). Tracked, it churns on every call AND — on Windows with core.autocrlf=true —
+  // shows perpetually modified (LF-written, CRLF-wanted), so sync-story/ship-story's bare `git merge`
+  // is refused ("local changes would be overwritten"). A transient local pointer has no business in
+  // git history; keep it on disk, out of git. (Root cause of a 3rd Sprint-1 zero-ship, 2026-06-13.)
+  '.valent-pipeline/run-state.json',
 ];
 
 /**
@@ -396,7 +402,19 @@ export function startStory({ root, story, targetBranch = '', prefix = 'story/',
     snapshotSha = snap.sha || null;
   }
 
-  const target = targetBranch || onBranch;
+  // An inline fix (--from-story) inherits its SOURCE story's recorded target — NOT the
+  // currently-checked-out branch. Running several fixes for one story back-to-back leaves HEAD on the
+  // previous fix's branch; defaulting `target` to onBranch made each later fix target (and, via the
+  // base check below, base on) its SIBLING fix branch — so the fixes silently chained onto the first
+  // fix's branch instead of the story, stranded off the real target (2026-06-14). An explicit
+  // --target still wins; onBranch stays the fallback for a plain story or a fix whose source has no
+  // flow record yet. With the right target, the base check (`!isMergedInto(source, target)`) also
+  // resolves correctly — the source story is unmerged into the REAL target, so the fix bases on it.
+  let inheritedTarget = null;
+  if (fromStory && !targetBranch) {
+    inheritedTarget = readFlowRecord(root, fromStory)?.target || null;
+  }
+  const target = targetBranch || inheritedTarget || onBranch;
   let base = target;
   let basedOnStory = false;
   if (fromStory) {