claude-code-session-manager 0.88.1 → 0.89.0

package/dist/index.html

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-Dp4Rc--q.js"></script>
+    <script type="module" crossorigin src="./assets/index-BcJqLDiY.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
     <link rel="stylesheet" crossorigin href="./assets/index-BHTX4OTc.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.88.1",
+  "version": "0.89.0",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

package/src/main/__tests__/scheduler-integration-failure-stamp.test.cjs

@@ -0,0 +1,41 @@
+/**
+ * scheduler-integration-failure-stamp.test.cjs — a worktree_integration_failed
+ * finalize stamps integrateBranch's failure subtype onto the job row, and the
+ * RCA report names it.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-integration-failure-stamp.test.cjs
+ */
+
+'use strict';
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const { stampIntegrationFailure } = require('../scheduler.cjs');
+const { buildRcaMarkdown } = require('../lib/rcaReport.cjs');
+
+test('stamps content_conflict kind and conflicted paths', () => {
+  const row = { slug: 'x' };
+  stampIntegrationFailure(row, { ok: false, failureKind: 'content_conflict', conflictedPaths: ['a.md'] });
+  assert.equal(row.integrationFailureKind, 'content_conflict');
+  assert.deepEqual(row.integrationConflictPaths, ['a.md']);
+});
+
+test('blocking_paths stamps kind only; no failure clears stale fields', () => {
+  const row = { integrationConflictPaths: ['old'] };
+  stampIntegrationFailure(row, { ok: false, failureKind: 'blocking_paths', blockingPaths: { tracked: ['f'], untracked: [] } });
+  assert.equal(row.integrationFailureKind, 'blocking_paths');
+  assert.equal('integrationConflictPaths' in row, false);
+  stampIntegrationFailure(row, null);
+  assert.equal('integrationFailureKind' in row, false);
+});
+
+test('RCA markdown names the subtype and conflicted paths', () => {
+  const job = {
+    slug: 'x', runId: 'r', integrationFailureKind: 'content_conflict',
+    integrationConflictPaths: ['docs/asset-pipeline.md'],
+  };
+  const md = buildRcaMarkdown({
+    job, verdict: 'worktree_integration_failed', meta: null, logTail: '', acText: '', failureClass: 'unknown',
+  });
+  assert.ok(md.includes('Integration failure subtype: content_conflict (conflicted paths: docs/asset-pipeline.md)'));
+});

package/src/main/__tests__/scheduler-mechanical-recovery.test.cjs

@@ -118,6 +118,29 @@ test('selectMechanicalRecoveryTarget: kill-switch SM_MECHANICAL_RECOVERY_DISABLE
   expect(selectMechanicalRecoveryTarget(eligibleJob())).toBeNull();
 });
 
+const conflictJob = (o = {}) => eligibleJob({ integrationFailureKind: 'content_conflict', integrationBaseHeadSha: 'aaa111', ...o });
+
+test('selectMechanicalRecoveryTarget: content_conflict with unchanged HEAD is skipped', () => {
+  expect(selectMechanicalRecoveryTarget(conflictJob(), 'aaa111')).toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: content_conflict with a moved HEAD returns a target', () => {
+  expect(selectMechanicalRecoveryTarget(conflictJob(), 'bbb222')).not.toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: blocking_paths with unchanged HEAD still returns a target', () => {
+  const job = eligibleJob({ integrationFailureKind: 'blocking_paths', integrationBaseHeadSha: 'aaa111' });
+  expect(selectMechanicalRecoveryTarget(job, 'aaa111')).not.toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: a pre-mc-01 row with no integrationFailureKind still returns a target', () => {
+  expect(selectMechanicalRecoveryTarget(eligibleJob(), 'aaa111')).not.toBeNull();
+});
+
+test('selectMechanicalRecoveryTarget: null currentHeadSha never skips', () => {
+  expect(selectMechanicalRecoveryTarget(conflictJob(), null)).not.toBeNull();
+});
+
 test('MECHANICALLY_RESOLVABLE_VERDICTS: closed set contains exactly worktree_integration_failed', () => {
   expect(Array.from(MECHANICALLY_RESOLVABLE_VERDICTS)).toEqual(['worktree_integration_failed']);
 });

package/src/main/build-info.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.88.1",
-  "gitSha": "03a101e69f411db8f3e5dfb465cb92a77365f32a",
-  "gitShortSha": "03a101e",
+  "version": "0.89.0",
+  "gitSha": "5ec3affd400f9a33189925d332d9c253fee1120c",
+  "gitShortSha": "5ec3aff",
   "gitBranch": "HEAD",
-  "builtAt": "2026-09-19T14:48:43.339Z",
+  "builtAt": "2026-09-19T22:24:34.621Z",
   "dirty": false
 }

package/src/main/lib/__tests__/gitWorktree.test.cjs

@@ -1310,3 +1310,175 @@ test('[guard][epic] integrateEpicBranch inherits the same guard and still merges
 
   await gitWorktree.cleanupEpicWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch });
 });
+
+// ── integrateBranch failure subtype classification (mc-01) ──
+
+test('[job] integrateBranch classifies a dirty different tracked file as failureKind blocking_paths', async () => {
+  const slug = 'test-slug-kind-blocking';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  fs.writeFileSync(path.join(worktree.dir, 'README.md'), 'job edit\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job edits README'], worktree.dir);
+  // Dirty (uncommitted), byte-DIFFERENT edit in the main tree blocks the merge.
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'different local edit\n', 'utf8');
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.reason).toMatch(/merge failed \(likely a real content conflict\)/);
+  expect(outcome.failureKind).toBe('blocking_paths');
+  expect(outcome.blockingPaths.tracked).toEqual(['README.md']);
+  expect(outcome.blockingPaths.untracked).toEqual([]);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch classifies diverging same-line commits as content_conflict with the conflicted path', async () => {
+  const slug = 'test-slug-kind-content';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  fs.writeFileSync(path.join(worktree.dir, 'README.md'), 'job edit\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job edits README'], worktree.dir);
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'main tree edit\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main tree edits README'], repoCwd);
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.failureKind).toBe('content_conflict');
+  expect(outcome.conflictedPaths).toEqual(['README.md']);
+  // The abort still ran.
+  expect(fs.existsSync(path.join(repoCwd, '.git', 'MERGE_HEAD'))).toBe(false);
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch classifies disjoint appends to the END of one file as content_conflict when the path is not allowlisted (.js)', async () => {
+  const slug = 'test-slug-kind-append';
+  fs.writeFileSync(path.join(repoCwd, 'src.js'), '// intro\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'add src.js'], repoCwd);
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  fs.appendFileSync(path.join(worktree.dir, 'src.js'), '\n// Section Six\nsix body\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job appends section six'], worktree.dir);
+  fs.appendFileSync(path.join(repoCwd, 'src.js'), '\n## Section Seven\nseven body\n\n## Section Ten\nten body\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main appends sections seven and ten'], repoCwd);
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.failureKind).toBe('content_conflict');
+  expect(outcome.conflictedPaths).toEqual(['src.js']);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+// ── pure-addition merge-conflict auto-resolve (mc-02) ──
+
+async function conflictScenario(slug, { base, side, main }) {
+  for (const [f, c] of Object.entries(base)) {
+    fs.mkdirSync(path.dirname(path.join(repoCwd, f)), { recursive: true });
+    fs.writeFileSync(path.join(repoCwd, f), c, 'utf8');
+  }
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'base files'], repoCwd);
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+  for (const [f, c] of Object.entries(side)) {
+    fs.mkdirSync(path.dirname(path.join(worktree.dir, f)), { recursive: true });
+    fs.writeFileSync(path.join(worktree.dir, f), c, 'utf8');
+  }
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job side'], worktree.dir);
+  for (const [f, c] of Object.entries(main)) {
+    fs.mkdirSync(path.dirname(path.join(repoCwd, f)), { recursive: true });
+    fs.writeFileSync(path.join(repoCwd, f), c, 'utf8');
+  }
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main side'], repoCwd);
+  return worktree;
+}
+
+const MARKER_RE = /^(<<<<<<<|\|\|\|\|\|\|\||=======|>>>>>>>)/m;
+
+test('[job] integrateBranch auto-resolves a pure-addition .md conflict by concatenating ours then theirs', async () => {
+  const slug = 'test-slug-pure-add';
+  const worktree = await conflictScenario(slug, {
+    base: { 'd.md': '# Doc\n\nintro\n' },
+    side: { 'd.md': '# Doc\n\nintro\n\n## Section A\na body\n' },
+    main: { 'd.md': '# Doc\n\nintro\n\n## Section B\nb body\n\n## Section C\nc body\n' },
+  });
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(true);
+  expect(outcome.autoResolved).toBe('pure_addition_concat');
+  expect(outcome.resolvedPaths).toEqual(['d.md']);
+  const merged = fs.readFileSync(path.join(repoCwd, 'd.md'), 'utf8');
+  expect(merged).toBe('# Doc\n\nintro\n\n## Section B\nb body\n\n## Section C\nc body\n\n## Section A\na body\n');
+  expect(merged).not.toMatch(MARKER_RE);
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+  expect(git(['log', '-1', '--format=%s'], repoCwd).trim()).toBe(`merge scheduler job ${slug}`);
+  expect(git(['rev-list', '--parents', '-n', '1', 'HEAD'], repoCwd).trim().split(' ').length).toBe(3);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch });
+});
+
+test('[job] integrateBranch does NOT auto-resolve a same-line .md edit and leaves the tree clean', async () => {
+  const slug = 'test-slug-pure-add-neg-sameline';
+  const worktree = await conflictScenario(slug, {
+    base: { 'd.md': 'intro\nORIGINAL LINE\n' },
+    side: { 'd.md': 'intro\nSIDE EDIT\n' },
+    main: { 'd.md': 'intro\nMAIN EDIT\n' },
+  });
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.autoResolved).toBeUndefined();
+  expect(outcome.failureKind).toBe('content_conflict');
+  expect(outcome.conflictedPaths).toEqual(['d.md']);
+  expect(fs.readFileSync(path.join(repoCwd, 'd.md'), 'utf8')).toBe('intro\nMAIN EDIT\n');
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch does NOT auto-resolve a pure-addition conflict on a non-allowlisted path', async () => {
+  const slug = 'test-slug-pure-add-neg-js';
+  const worktree = await conflictScenario(slug, {
+    base: { 'src/thing.js': '// intro\n' },
+    side: { 'src/thing.js': '// intro\n// A\n' },
+    main: { 'src/thing.js': '// intro\n// B\n// C\n' },
+  });
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.autoResolved).toBeUndefined();
+  expect(outcome.failureKind).toBe('content_conflict');
+  expect(fs.readFileSync(path.join(repoCwd, 'src/thing.js'), 'utf8')).toBe('// intro\n// B\n// C\n');
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch bails the whole merge when only some conflicted paths are provable (mixed .md + .js)', async () => {
+  const slug = 'test-slug-pure-add-neg-mixed';
+  const worktree = await conflictScenario(slug, {
+    base: { 'd.md': 'intro\n', 'src/thing.js': 'ORIGINAL\n' },
+    side: { 'd.md': 'intro\n## A\n', 'src/thing.js': 'SIDE\n' },
+    main: { 'd.md': 'intro\n## B\n', 'src/thing.js': 'MAIN\n' },
+  });
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.autoResolved).toBeUndefined();
+  expect(outcome.conflictedPaths).toEqual(['d.md', 'src/thing.js']);
+  expect(fs.readFileSync(path.join(repoCwd, 'd.md'), 'utf8')).toBe('intro\n## B\n');
+  expect(fs.readFileSync(path.join(repoCwd, 'src/thing.js'), 'utf8')).toBe('MAIN\n');
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+  expect(fs.existsSync(path.join(repoCwd, '.git', 'MERGE_HEAD'))).toBe(false);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});

package/src/main/lib/gitWorktree.cjs

@@ -940,6 +940,167 @@ function parseBlockingMergePaths(stderrText) {
   return { tracked: Array.from(new Set(tracked)), untracked: Array.from(new Set(untracked)) };
 }
 
+/**
+ * Classifies a failed `git merge` from its stderr — additive metadata for
+ * integrateBranch's `ok: false` results (the `reason` string is untouched).
+ * 'blocking_paths' = git refused up-front over dirty/untracked paths
+ * (auto-resolvable, PRD 1125); 'content_conflict' = a genuine 3-way
+ * `CONFLICT (` (deterministic on every retry); 'other' = anything else.
+ * For content_conflict, reads the unmerged paths — MUST be called before
+ * `git merge --abort`, which clears them. Never throws; a failed read
+ * yields `conflictedPaths: []`. O(p log p) in the conflicted-path count.
+ */
+async function classifyMergeFailure({ cwd, stderrText, stdoutText }) {
+  const blocking = parseBlockingMergePaths(stderrText);
+  if (blocking) return { failureKind: 'blocking_paths', blockingPaths: blocking };
+  // git prints `CONFLICT (...)` lines on STDOUT, not stderr.
+  if (/CONFLICT \(/m.test(`${stdoutText || ''}\n${stderrText || ''}`)) {
+    let conflictedPaths = [];
+    try {
+      const out = await execGit(['diff', '--name-only', '--diff-filter=U'], { cwd, timeout: 10_000 });
+      conflictedPaths = Array.from(new Set(out.split('\n').map((l) => l.trim()).filter(Boolean))).sort();
+    } catch { /* best effort — abort must still run */ }
+    return { failureKind: 'content_conflict', conflictedPaths };
+  }
+  return { failureKind: 'other' };
+}
+
+// Extensions eligible for the pure-addition auto-resolve. All-or-nothing across
+// a merge: one conflicted path outside this list means no auto-resolve at all.
+const AUTO_RESOLVE_EXTENSIONS = new Set(['.md', '.markdown', '.txt', '.rst']);
+
+/**
+ * Renders `git merge-file -p --diff3` over the index's three conflict stages
+ * of `p`. Returns the merged text (with markers), or null when any stage is
+ * missing/unreadable, a stage is not valid UTF-8 (the round-trip would not be
+ * byte-exact), or git itself errors. `merge-file` exits with the conflict
+ * count (1..127) on a clean run — only >127 or a signal is an error. Never
+ * throws. O(file size).
+ */
+async function renderStagesDiff3({ cwd, p }) {
+  let tmp = null;
+  try {
+    tmp = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-mergefile-'));
+    const files = [];
+    for (const stage of [2, 1, 3]) { // ours, base, theirs — merge-file's argument order
+      const content = await execGit(['cat-file', 'blob', `:${stage}:${p}`], { cwd, timeout: 10_000 });
+      if (content.includes('�')) return null;
+      const f = path.join(tmp, `stage${stage}`);
+      await fsp.writeFile(f, content, 'utf8');
+      files.push(f);
+    }
+    try {
+      return await execGit(['merge-file', '-p', '--diff3', '-L', 'ours', '-L', 'base', '-L', 'theirs', ...files], { cwd, timeout: 10_000 });
+    } catch (e) {
+      if (e && typeof e.code === 'number' && e.code >= 1 && e.code <= 127 && typeof e.stdoutText === 'string') return e.stdoutText;
+      return null;
+    }
+  } catch {
+    return null;
+  } finally {
+    if (tmp) { try { await fsp.rm(tmp, { recursive: true, force: true }); } catch { /* best effort */ } }
+  }
+}
+
+/**
+ * Parses diff3 merge-file output into segments: `{ text }` for pass-through
+ * regions and `{ ours, base, theirs }` (arrays of lines) for conflict hunks.
+ * Returns null on any out-of-order marker or an unterminated hunk. A marker
+ * prefix is only meaningful in its expected state; `=======` inside the ours
+ * or theirs section (e.g. a markdown setext underline) is treated as
+ * unparseable rather than guessed at. O(n) in output lines.
+ */
+function parseDiff3Output(output) {
+  const lines = output.split('\n');
+  const segments = [];
+  let plain = [];
+  let hunk = null;
+  let state = 'plain';
+  for (const line of lines) {
+    const isOpen = line.startsWith('<<<<<<< ');
+    const isBase = line.startsWith('||||||| ');
+    const isSep = line.startsWith('=======');
+    const isClose = line.startsWith('>>>>>>> ');
+    if (state === 'plain') {
+      if (isBase || isClose) return null;
+      if (isOpen) {
+        segments.push({ lines: plain });
+        plain = [];
+        hunk = { ours: [], base: [], theirs: [] };
+        state = 'ours';
+      } else {
+        plain.push(line);
+      }
+    } else if (state === 'ours') {
+      if (isOpen || isSep || isClose) return null;
+      if (isBase) state = 'base'; else hunk.ours.push(line);
+    } else if (state === 'base') {
+      if (isOpen || isBase || isClose) return null;
+      if (isSep && line === '=======') state = 'theirs'; else if (isSep) return null; else hunk.base.push(line);
+    } else {
+      if (isOpen || isBase || isSep) return null;
+      if (isClose) { segments.push({ hunk }); hunk = null; state = 'plain'; } else hunk.theirs.push(line);
+    }
+  }
+  if (state !== 'plain') return null;
+  segments.push({ lines: plain });
+  return segments;
+}
+
+/**
+ * True ONLY when, for EVERY path, the index holds all three conflict stages
+ * and every diff3 conflict hunk has an EMPTY base section (both sides purely
+ * added text where the merge base had nothing). Proven from the bytes, never
+ * assumed; fails toward false on every error path. Never throws.
+ */
+async function isPureAdditionConflict({ cwd, paths }) {
+  try {
+    if (!Array.isArray(paths) || !paths.length) return false;
+    for (const p of paths) {
+      const out = await renderStagesDiff3({ cwd, p });
+      if (out === null) return false;
+      const segments = parseDiff3Output(out);
+      if (!segments) return false;
+      const hunks = segments.filter((s) => s.hunk);
+      if (!hunks.length) return false;
+      if (hunks.some((s) => s.hunk.base.length !== 0)) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Rewrites each conflicted path in the working tree with every conflict hunk
+ * replaced by OURS then THEIRS (no markers, base, reordering, or dedup);
+ * non-conflicted regions pass through unchanged. Renders ALL paths before
+ * writing any so a late failure leaves nothing half-rewritten. Throws on any
+ * failure — the caller aborts the merge.
+ */
+async function resolveByConcatenation({ cwd, paths }) {
+  const rendered = [];
+  for (const p of paths) {
+    const out = await renderStagesDiff3({ cwd, p });
+    const segments = out === null ? null : parseDiff3Output(out);
+    if (!segments) throw new Error(`cannot render conflict for ${p}`);
+    rendered.push({ p, text: joinSegments(segments) });
+  }
+  for (const { p, text } of rendered) {
+    await fsp.writeFile(path.join(cwd, p), text, 'utf8');
+  }
+}
+
+/** Rebuilds file text from parsed segments, hunks contributing ours+theirs lines. */
+function joinSegments(segments) {
+  const out = [];
+  for (const seg of segments) {
+    if (seg.hunk) out.push(...seg.hunk.ours, ...seg.hunk.theirs);
+    else out.push(...seg.lines);
+  }
+  return out.join('\n');
+}
+
 /**
  * Resolves `cwd`'s default branch, without ever hardcoding `main`: prefers
  * the remote-tracked default (`origin/HEAD`, set by `git clone`/`git remote
@@ -949,6 +1110,16 @@ function parseBlockingMergePaths(stderrText) {
  * this chain (no remote, no config, no matching local branch) simply falls
  * through to the next source.
  */
+// HEAD sha of `cwd` (null on any failure) — stamped on a failed integration so
+// mechanical recovery can tell whether the base tree has moved since.
+async function readHeadSha(cwd) {
+  try {
+    return (await execGit(['rev-parse', 'HEAD'], { cwd, timeout: 10_000 })).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
 async function resolveDefaultBranch(cwd) {
   try {
     const out = (await execGit(['symbolic-ref', 'refs/remotes/origin/HEAD'], { cwd, timeout: 10_000 })).trim();
@@ -1112,15 +1283,36 @@ async function integrateBranch({ cwd, branch, key, kind, carriedPaths }) {
             resolvedPaths: allPaths,
           };
         } catch (retryErr) {
-          try { await execGit(['merge', '--abort'], { cwd, timeout: 10_000 }); } catch { /* nothing to abort */ }
           const retryText = (retryErr && (retryErr.stderrText || retryErr.message)) || String(retryErr);
-          return { ok: false, reason: `merge failed (likely a real content conflict): ${retryText}` };
+          const retryClass = await classifyMergeFailure({ cwd, stderrText: retryText, stdoutText: retryErr && retryErr.stdoutText });
+          try { await execGit(['merge', '--abort'], { cwd, timeout: 10_000 }); } catch { /* nothing to abort */ }
+          return { ok: false, reason: `merge failed (likely a real content conflict): ${retryText}`, ...retryClass, baseHeadSha: await readHeadSha(cwd) };
         }
       }
     }
+    // Read the conflicted paths BEFORE the abort — it clears the index stages.
+    const failureClass = await classifyMergeFailure({ cwd, stderrText, stdoutText: e && e.stdoutText });
+    // Pure-addition auto-resolve: two jobs appended different text to the same
+    // doc. All-or-nothing; any doubt or failure falls through to the abort.
+    if (
+      process.env.SM_PURE_ADDITION_MERGE_DISABLE !== '1'
+      && failureClass.failureKind === 'content_conflict'
+      && failureClass.conflictedPaths.length
+      && failureClass.conflictedPaths.every((p) => AUTO_RESOLVE_EXTENSIONS.has(path.extname(p).toLowerCase()))
+    ) {
+      try {
+        const paths = failureClass.conflictedPaths;
+        if (await isPureAdditionConflict({ cwd, paths })) {
+          await resolveByConcatenation({ cwd, paths });
+          await execGit(['add', ...paths], { cwd, timeout: 30_000 });
+          await execGit(['commit', '-m', mergeMessage], { cwd, timeout: 30_000 });
+          return { ok: true, integrated: true, mergeCommit: true, autoResolved: 'pure_addition_concat', resolvedPaths: paths };
+        }
+      } catch { /* fall through to the abort */ }
+    }
     // Abort a half-applied merge so `cwd` isn't left in a mid-merge state.
     try { await execGit(['merge', '--abort'], { cwd, timeout: 10_000 }); } catch { /* nothing to abort */ }
-    return { ok: false, reason: `merge failed (likely a real content conflict): ${stderrText}` };
+    return { ok: false, reason: `merge failed (likely a real content conflict): ${stderrText}`, ...failureClass, baseHeadSha: await readHeadSha(cwd) };
   }
 }
 

package/src/main/lib/rcaReport.cjs

@@ -295,9 +295,16 @@ function buildRcaMarkdown({ job, verdict, meta, logTail, acText, failureClass, i
   const durationMs = meta?.durationMs != null ? `${meta.durationMs}ms` : 'unknown';
   const prevention = PREVENTION_HINTS[failureClass] ?? PREVENTION_HINTS[FAILURE_CLASSES.UNKNOWN];
 
+  const integrationLine = job.integrationFailureKind
+    ? `\n\nIntegration failure subtype: ${job.integrationFailureKind}` +
+      (job.integrationFailureKind === 'content_conflict' && Array.isArray(job.integrationConflictPaths)
+        ? ` (conflicted paths: ${job.integrationConflictPaths.join(', ') || 'unknown'})`
+        : '')
+    : '';
+
   const sections = [
     `# What happened\n\nJob \`${job.slug}\` was parked in \`needs_review\` with verifier verdict ` +
-      `\`${verdict}\` (${humanVerdict(verdict)}).${job.error ? `\n\n${job.error}` : ''}`,
+      `\`${verdict}\` (${humanVerdict(verdict)}).${job.error ? `\n\n${job.error}` : ''}${integrationLine}`,
     `# Evidence\n\n- Exit code: ${exitCode}\n- Duration: ${durationMs}\n\nLast 60 log lines:\n\n\`\`\`\n${last60 || '(no log available)'}\n\`\`\``,
     `# The PRD's acceptance criteria\n\n${acText || '(acceptance criteria not found — original PRD may have been archived or removed)'}`,
     `# Likely failure class\n\n**${failureClass}**\n\nPrevention: ${prevention}`,