valent-pipeline 0.19.15 → 0.19.16

package/package.json

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

package/src/lib/git-flow.js

@@ -156,6 +156,69 @@ function ensureExcluded(root, worktreeDir) {
   appendFileSync(excludePath, `${content.endsWith('\n') || content === '' ? '' : '\n'}${line}\n`);
 }
 
+// Per-story evidence STATE the harness rewrites every run/retry: the run journal (index.jsonl), the
+// gate-pin ledger (pins.jsonl), the resolved task graph, and the stage-verdict ledger. These are
+// DERIVED records — the board reads them off disk, and the on-disk evidence hash-chain (not git
+// history) is the tamper model — yet commitAll's `git add -A` would TRACK them, and a tracked file
+// that churns on a retry leaves the tree dirty. That dirt refuses the ship merge: both isDirty() AND
+// git's own `merge`/`checkout` see WHOLE-tree dirt — GIT_DIRT_EXCLUDE (evidence.js) only spares the
+// read-side coherence/pin checks, never the merge. Fix = keep them out of git via .git/info/exclude,
+// never a tracked .gitignore edit (which would itself dirty the tree — the same rule ensureExcluded
+// states for the worktree container). One list: a new state-file type is a single line here, not a
+// per-project .gitignore chase. The board still reads them off disk; only their git-history copy goes.
+const STATE_EXCLUDE_PATTERNS = [
+  'stories/*/evidence/index.jsonl',
+  'stories/*/evidence/pins.jsonl',
+  'stories/*/evidence/resolved-graph.json',
+  'stories/*/evidence/stage-results.json',
+];
+
+/**
+ * Append the evidence-state ignore patterns to .git/info/exclude (idempotent; shared across linked
+ * worktrees via the common git dir). Local-only, so it never dirties the tree the flow keeps clean.
+ * Called at the top of commitAll BEFORE `git add -A`, so these files are never newly tracked.
+ */
+function ensureStateExcluded(root) {
+  let commonDir;
+  try {
+    commonDir = git(root, ['rev-parse', '--git-common-dir']);
+  } catch {
+    return; // not a repo / git unavailable — nothing to exclude (commitAll's own callers handle the skip)
+  }
+  const excludePath = join(isAbsolute(commonDir) ? commonDir : join(root, commonDir), 'info', 'exclude');
+  let content = '';
+  try {
+    content = readFileSync(excludePath, 'utf-8');
+  } catch { /* no exclude file yet */ }
+  const have = new Set(content.split(/\r?\n/));
+  const missing = STATE_EXCLUDE_PATTERNS.filter((p) => !have.has(p));
+  if (!missing.length) return;
+  mkdirSync(join(excludePath, '..'), { recursive: true });
+  appendFileSync(excludePath, `${content.endsWith('\n') || content === '' ? '' : '\n'}${missing.join('\n')}\n`);
+}
+
+/**
+ * Self-heal projects an older version (or a prior run) already committed these files into: untrack
+ * them so they stop dirtying the tree. `git rm --cached` drops them from the index but KEEPS them on
+ * disk (the board still reads them). Best-effort over the whole set — a file that can't be untracked
+ * (e.g. staged AND modified) is left for the `git add -A` sweep, which still yields a clean tree for
+ * the merge. Only call on the commit path (after isDirty), so the staged removals ride the commit
+ * that is about to happen rather than producing a surprise commit on an otherwise-clean tree.
+ */
+function untrackStateFiles(root) {
+  let tracked = [];
+  try {
+    tracked = git(root, ['ls-files', '--', ...STATE_EXCLUDE_PATTERNS]).split('\n').filter(Boolean);
+  } catch {
+    return;
+  }
+  if (!tracked.length) return;
+  try {
+    git(root, ['rm', '--cached', '--quiet', '--', ...tracked]);
+    console.error(`git-flow: untracked ${tracked.length} regenerable evidence-state file(s) (kept on disk) — they churn every run and otherwise dirty the tree, refusing the ship merge.`);
+  } catch { /* leave them for the add -A sweep below — a committed churner is still a clean tree */ }
+}
+
 /** Find the registered worktree (path) that has `branch` checked out, or null. */
 function worktreeForBranch(root, branch) {
   const out = git(root, ['worktree', 'list', '--porcelain']);
@@ -292,7 +355,9 @@ function commitAll(root, message) {
       `sweeping now would conclude it and commit unreviewed half-merged code. Resolve or ` +
       `\`git merge --abort\` first.`);
   }
+  ensureStateExcluded(root); // keep regenerable evidence-state churn out of git BEFORE `add -A` ever sees it
   if (!isDirty(root)) return { committed: false };
+  untrackStateFiles(root); // self-heal any already-tracked churners into this very commit
   git(root, ['add', '-A']);
   git(root, ['commit', '-m', message]);
   return { committed: true, sha: git(root, ['rev-parse', 'HEAD']) };