claude-code-session-manager 0.79.0 → 0.81.0

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

@@ -19,7 +19,12 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { selectReapableJobs, mapOutcomeToGateOutcome, classifyRunOutcome } = require('../reaperHelpers.cjs');
+const { spawn } = require('node:child_process');
+const {
+  selectReapableJobs, mapOutcomeToGateOutcome, classifyRunOutcome,
+  findLiveProcessForJob, logHasOutput, resolvePidlessGateOutcome,
+  isAlreadySatisfiedOnMain,
+} = require('../reaperHelpers.cjs');
 const { detectRateLimitInLog } = require('../rateLimitDetect.cjs');
 
 const NOW = Date.parse('2026-09-01T12:00:00.000Z');
@@ -101,6 +106,33 @@ test('non-running rows are never considered, pidless or not', () => {
   assert.deepStrictEqual(warnings, []);
 });
 
+test('pidless + past grace + findLiveProcess finds a pid → recovered, never reaped', () => {
+  const jobs = [{ slug: 'zombie-alive', status: 'running', startedAt: agoMin(464) }];
+  const findLiveProcess = () => 2174739;
+  const { reapable, recovered, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE, findLiveProcess });
+  assert.deepStrictEqual(reapable, []);
+  assert.deepStrictEqual(warnings, []);
+  assert.strictEqual(recovered.length, 1);
+  assert.strictEqual(recovered[0].slug, 'zombie-alive');
+  assert.strictEqual(recovered[0].pid, 2174739);
+});
+
+test('pidless + past grace + findLiveProcess finds nothing → reaped exactly as today', () => {
+  const jobs = [{ slug: 'zombie-dead', status: 'running', startedAt: agoMin(464) }];
+  const findLiveProcess = () => null;
+  const { reapable, recovered } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE, findLiveProcess });
+  assert.deepStrictEqual(recovered, []);
+  assert.strictEqual(reapable.length, 1);
+  assert.strictEqual(reapable[0].pidless, true);
+});
+
+test('pidless + past grace + no findLiveProcess supplied → reaped exactly as before this PRD', () => {
+  const jobs = [{ slug: 'zombie', status: 'running', startedAt: agoMin(464) }];
+  const { reapable, recovered } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
+  assert.strictEqual(reapable.length, 1);
+  assert.deepStrictEqual(recovered, []);
+});
+
 test('mixed batch: each row classified independently', () => {
   const jobs = [
     { slug: 'zombie', status: 'running', startedAt: agoMin(464) },
@@ -220,3 +252,90 @@ test('classifyRunOutcome: a clean success log still classifies as success', () =
   const p = writeTmpLog('{"type":"result","subtype":"success","is_error":false,"result":"done"}\n');
   assert.strictEqual(classifyRunOutcome(p), 'success');
 });
+
+// findLiveProcessForJob — the /proc positive liveness scan behind the
+// 2026-09-06 stranded-branch incident (234-uranus-eight-tails-ox: marked
+// failed/never_ran while its process was alive and still writing to its
+// worktree). Linux-only, and a safe no-op everywhere else per its own header.
+
+test('findLiveProcessForJob: finds a live process via /proc/<pid>/cwd match', async () => {
+  if (process.platform !== 'linux' || !fs.existsSync('/proc')) return;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reaper-liveness-'));
+  const child = spawn('sleep', ['5'], { cwd: dir, stdio: 'ignore' });
+  try {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const pid = findLiveProcessForJob({ slug: 'irrelevant-slug' }, { worktreeDir: dir });
+    assert.strictEqual(pid, child.pid);
+  } finally {
+    child.kill('SIGKILL');
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('findLiveProcessForJob: no live process anywhere → null', () => {
+  if (process.platform !== 'linux' || !fs.existsSync('/proc')) return;
+  const pid = findLiveProcessForJob(
+    { slug: 'definitely-not-a-real-running-slug-xyz123' },
+    { worktreeDir: '/nonexistent/worktree/dir/xyz123' },
+  );
+  assert.strictEqual(pid, null);
+});
+
+// logHasOutput — the literal "did the run dir produce any log output" check
+// that gates whether a pidless reap may assert gateOutcome: 'never_ran'.
+
+test('logHasOutput: missing file → false', () => {
+  assert.strictEqual(logHasOutput('/nonexistent/path/does-not-exist.log'), false);
+});
+
+test('logHasOutput: empty file → false', () => {
+  const p = writeTmpLog('');
+  assert.strictEqual(logHasOutput(p), false);
+});
+
+test('logHasOutput: file with content → true', () => {
+  const p = writeTmpLog('some real log output\n');
+  assert.strictEqual(logHasOutput(p), true);
+});
+
+test('logHasOutput: null path → false', () => {
+  assert.strictEqual(logHasOutput(null), false);
+});
+
+// resolvePidlessGateOutcome — never_ran is asserted ONLY when the run dir has
+// no log output; a run dir WITH output must not claim never_ran even if no
+// clean result event was found in it.
+
+test('resolvePidlessGateOutcome: no output → never_ran, regardless of raw outcome (terminalizes as today)', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('no_result', false), 'never_ran');
+  assert.strictEqual(resolvePidlessGateOutcome('success', false), 'never_ran');
+});
+
+test('resolvePidlessGateOutcome: output present + no_result → failed, never never_ran', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('no_result', true), 'failed');
+});
+
+test('resolvePidlessGateOutcome: output present + success → passed', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('success', true), 'passed');
+});
+
+test('resolvePidlessGateOutcome: output present + failed → failed', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('failed', true), 'failed');
+});
+
+// isAlreadySatisfiedOnMain — PRD 1136. Pure decision layer: given the
+// already-git-queried list of satisfying commits, decide whether the
+// commit-guard's 'silent_no_op' verdict should be overridden to 'completed'.
+
+test('isAlreadySatisfiedOnMain: a satisfying commit → completed-shaped verdict naming the sha', () => {
+  const verdict = isAlreadySatisfiedOnMain(['5de4134abc123', 'a96de98def456']);
+  assert.strictEqual(verdict.sha, '5de4134abc123');
+  assert.strictEqual(verdict.verdict, 'already_satisfied_on_main');
+  assert.match(verdict.reason, /5de4134abc123/);
+});
+
+test('isAlreadySatisfiedOnMain: no satisfying commits → null — the gate must not be weakened into always-passing', () => {
+  assert.strictEqual(isAlreadySatisfiedOnMain([]), null);
+  assert.strictEqual(isAlreadySatisfiedOnMain(null), null);
+  assert.strictEqual(isAlreadySatisfiedOnMain(undefined), null);
+});

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

@@ -11,7 +11,7 @@
 
 // vitest globals (test) — same convention as the other .cjs tests.
 const assert = require('node:assert/strict');
-const { pickForProject, DEFAULT_PROJECT_CWD } = require('../schedulerBatch.cjs');
+const { pickForProject, findBlockingDep, DEFAULT_PROJECT_CWD, DEP_HISTORY_FAIL_OPEN } = require('../schedulerBatch.cjs');
 
 const CWD = DEFAULT_PROJECT_CWD;
 
@@ -74,14 +74,66 @@ test('still resolves an exact-slug dep (dep written WITH the NN- prefix)', () =>
   assert.deepEqual(batch.map((j) => j.slug), ['873-leftnav-two-face-framework']);
 });
 
-test('a dep with no row at all is treated as already done (archived/retired)', () => {
+// PRD 1122 — a dep slug with no live row is no longer auto-satisfied by
+// absence alone. It must show up in the caller's precomputed
+// history/archive Set (5th arg, built once per tick by
+// scheduler.cjs's computeDepHistorySatisfaction) or it HOLDS as
+// 'unresolved'. Observed live on starry-night-ships: a typo'd/format-
+// mismatched dep slug used to be silently indistinguishable from one
+// genuinely retired to history.
+test('a dep with no row IS treated as done when the caller supplies it as history/archive-satisfied', () => {
   const jobs = [
     job('874-nav-face-project-home', 'pending', { dependsOn: ['some-long-archived-prd'] }),
   ];
-  const { batch } = pick(jobs);
+  const { batch } = pickForProject(jobs, new Set(), 3, new Map(), new Set(['some-long-archived-prd']));
+  assert.deepEqual(batch.map((j) => j.slug), ['874-nav-face-project-home']);
+});
+
+test('a dep with no row and NOT in the history/archive set HOLDS as unresolved, with a named actionable reason', () => {
+  const jobs = [
+    job('874-nav-face-project-home', 'pending', { dependsOn: ['some-typo-d-prd'] }),
+  ];
+  const { batch, reason, holds } = pick(jobs);
+  assert.deepEqual(batch, []);
+  assert.match(reason, /depends-gate/);
+  assert.match(reason, /unresolvable dependencies/);
+  assert.match(reason, /874-nav-face-project-home <- some-typo-d-prd/);
+  assert.match(reason, /fix the dependsOn entry or archive the dependent/);
+  const hold = holds.find((h) => h.slug === '874-nav-face-project-home');
+  assert.equal(hold.depStatus, 'unresolved');
+});
+
+test('the double-prefixed-row regression: a row named 253-253-x referenced as bare x holds as unresolved', () => {
+  // bareSlug strips exactly ONE leading `NN-` run, so '253-253-x' bares to
+  // '253-x' — it does NOT bare-match dependsOn's 'x'. The double-prefixed row
+  // is therefore genuinely invisible to both exact and bare matching, the
+  // same as a typo — this is the exact 2026-09-06 starry-night-ships report.
+  const jobs = [
+    job('253-253-x', 'running'),
+    job('254-next', 'pending', { dependsOn: ['x'] }),
+  ];
+  const { batch, holds, reason } = pick(jobs);
+  assert.deepEqual(batch.map((j) => j.slug), []);
+  assert.match(reason, /unresolvable dependencies/);
+  const hold = holds.find((h) => h.slug === '254-next');
+  assert.equal(hold.dep, 'x');
+  assert.equal(hold.depStatus, 'unresolved');
+});
+
+test('DEP_HISTORY_FAIL_OPEN preserves the pre-1122 fail-open behaviour for a read failure', () => {
+  const jobs = [
+    job('874-nav-face-project-home', 'pending', { dependsOn: ['some-long-archived-prd'] }),
+  ];
+  const { batch } = pickForProject(jobs, new Set(), 3, new Map(), DEP_HISTORY_FAIL_OPEN);
   assert.deepEqual(batch.map((j) => j.slug), ['874-nav-face-project-home']);
 });
 
+test('findBlockingDep: bare-name resolution against satisfiedSlugs matches the live-row bare-name rule', () => {
+  const dependent = job('254-next', 'pending', { dependsOn: ['x'] });
+  assert.equal(findBlockingDep(dependent, [dependent], new Set(['253-x'])), undefined);
+  assert.equal(findBlockingDep(dependent, [dependent], new Set()), 'x');
+});
+
 test('a FAILED bare-named dep holds the dependent and reports an explicit reason', () => {
   const jobs = [
     job('873-leftnav-two-face-framework', 'failed'),
@@ -203,7 +255,7 @@ test('reports a per-job hold record naming the blocking dep and its status', ()
   const { batch, holds } = pick(jobs, new Set(), 5);
   assert.deepEqual(batch.map((j) => j.slug), ['985-foundation']);
   assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'pending' },
+    { slug: '986-dependent', dep: 'foundation', depStatus: 'pending', rootSlug: '985-foundation', rootStatus: 'pending' },
   ]);
 });
 
@@ -214,7 +266,7 @@ test('hold record carries a running dep status', () => {
   ];
   const { holds } = pick(jobs, new Set(['985-foundation']), 5);
   assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'running' },
+    { slug: '986-dependent', dep: 'foundation', depStatus: 'running', rootSlug: '985-foundation', rootStatus: 'running' },
   ]);
 });
 
@@ -227,7 +279,7 @@ test('hold record carries a failed dep status alongside the depends-gate reason'
   assert.deepEqual(batch, []);
   assert.match(reason, /depends-gate/);
   assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'failed' },
+    { slug: '986-dependent', dep: 'foundation', depStatus: 'failed', rootSlug: '985-foundation', rootStatus: 'failed' },
   ]);
 });
 
@@ -241,7 +293,7 @@ test('hold record carries a skipped dep status alongside the depends-gate reason
   assert.match(reason, /depends-gate/);
   assert.match(reason, /never-ran dependencies/);
   assert.deepEqual(holds, [
-    { slug: '986-dependent', dep: 'foundation', depStatus: 'skipped' },
+    { slug: '986-dependent', dep: 'foundation', depStatus: 'skipped', rootSlug: '985-foundation', rootStatus: 'skipped' },
   ]);
 });
 

package/src/main/lib/branchSweep.cjs

@@ -0,0 +1,127 @@
+/**
+ * branchSweep.cjs — periodic recovery for `sm-job/<slug>` branches whose
+ * owning job row was terminalized (or lost entirely) without the branch ever
+ * being merged back into its project's HEAD (PRD 1135).
+ *
+ * The reaper's own liveness check (reaperHelpers.cjs findLiveProcessForJob)
+ * stops NEW stranding at the source; this module recovers anything already
+ * stranded before that fix landed, or by a crash the liveness check can't
+ * cover (app killed between a job's commit and its own integrateJobBranch
+ * call). Two halves of one invariant — see the PRD body.
+ *
+ * Deliberately never deletes a branch (`git branch -D` or otherwise) —
+ * reclaiming disk is out of scope; this module only ever merges forward.
+ *
+ * Kept free of scheduler.cjs / electron / queueStore coupling (same reason
+ * reaperHelpers.cjs is separate — importable and unit-testable without
+ * requiring electron) — callers own persisting a `conflict` result onto a
+ * job row.
+ */
+'use strict';
+
+const { execFile } = require('node:child_process');
+const gitWorktree = require('./gitWorktree.cjs');
+
+function execGit(cwd, args, timeout = 20_000) {
+  return new Promise((resolve, reject) => {
+    execFile('git', ['-C', cwd, ...args], { timeout, windowsHide: true, encoding: 'utf8' }, (err, stdout, stderr) => {
+      if (err) {
+        err.stderrText = stderr;
+        reject(err);
+        return;
+      }
+      resolve(stdout || '');
+    });
+  });
+}
+
+/** List every local branch under `refs/heads/sm-job/*`. Never throws. */
+async function listSmJobBranches(cwd) {
+  try {
+    const out = await execGit(cwd, ['for-each-ref', '--format=%(refname:short)', 'refs/heads/sm-job/*']);
+    return out.split('\n').map((l) => l.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/** Branch names currently checked out in any linked worktree (incl. main). Never throws. */
+async function listCheckedOutBranches(cwd) {
+  try {
+    const out = await execGit(cwd, ['worktree', 'list', '--porcelain']);
+    return gitWorktree.parseWorktreeListPorcelain(out)
+      .map((e) => e.branch)
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+const TERMINAL_JOB_STATUSES = new Set(['completed', 'failed', 'skipped']);
+
+/**
+ * sweepStrandedJobBranches({ cwd, jobs, attemptedBranches }) → { results }
+ *
+ * `jobs` is the full in-memory queue snapshot (any project's rows may be
+ * present; matched by slug only, since a slug is globally unique). `attemptedBranches`
+ * is a caller-owned `Set` of `"<cwd>::<branch>"` keys — persisted across calls
+ * (in-memory is enough: the goal is "not retried every cycle forever" while
+ * the process is up, not durability across a restart) so a branch that
+ * conflicts once is never retried again in the same process lifetime.
+ *
+ * Each result is `{ branch, slug, action }` where action is one of:
+ *   'skip-checked-out'   — branch is checked out in a live worktree, left alone
+ *   'no-op-merged'       — branch has no commits beyond HEAD, nothing to do
+ *   'skip-active-row'    — job row exists and is NOT terminal, left alone
+ *   'skip-already-attempted' — a prior sweep already tried and failed this branch
+ *   'integrated'         — merged into HEAD this pass (`integration` attached)
+ *   'conflict'           — one bounded integrateBranch attempt failed (`integration` attached)
+ *
+ * SM_BRANCH_SWEEP_DISABLE=1 restores today's behaviour exactly (no-op),
+ * mirroring SM_RESUME_RECOVERY_DISABLE.
+ */
+async function sweepStrandedJobBranches({ cwd, jobs, attemptedBranches }) {
+  if (process.env.SM_BRANCH_SWEEP_DISABLE === '1') return { results: [] };
+  if (!cwd || !(await gitWorktree.isGitRepo(cwd))) return { results: [] };
+
+  const attempted = attemptedBranches instanceof Set ? attemptedBranches : new Set();
+  const branches = await listSmJobBranches(cwd);
+  if (!branches.length) return { results: [] };
+  const checkedOut = new Set(await listCheckedOutBranches(cwd));
+  const jobsBySlug = new Map((Array.isArray(jobs) ? jobs : []).map((j) => [j.slug, j]));
+
+  const results = [];
+  for (const branch of branches) {
+    const slug = gitWorktree.keyFromBranch('job', branch);
+    if (checkedOut.has(branch)) {
+      results.push({ branch, slug, action: 'skip-checked-out' });
+      continue;
+    }
+    const merged = await gitWorktree.isBranchMergedIntoHead(cwd, branch);
+    if (merged) {
+      results.push({ branch, slug, action: 'no-op-merged' });
+      continue;
+    }
+    const row = slug ? jobsBySlug.get(slug) : null;
+    const terminalOrMissing = !row || TERMINAL_JOB_STATUSES.has(row.status);
+    if (!terminalOrMissing) {
+      results.push({ branch, slug, action: 'skip-active-row' });
+      continue;
+    }
+    const attemptKey = `${cwd}::${branch}`;
+    if (attempted.has(attemptKey)) {
+      results.push({ branch, slug, action: 'skip-already-attempted' });
+      continue;
+    }
+    attempted.add(attemptKey);
+    const integration = await gitWorktree.integrateJobBranch({ cwd, branch, slug: slug || branch });
+    results.push({ branch, slug, action: integration.ok ? 'integrated' : 'conflict', integration });
+  }
+  return { results };
+}
+
+module.exports = {
+  listSmJobBranches,
+  listCheckedOutBranches,
+  sweepStrandedJobBranches,
+};

package/src/main/lib/depSlugResolve.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * depSlugResolve.cjs — the single `dependsOn` slug-resolution rule (PRD 832),
+ * shared by schedulerBatch.cjs's findBlockingDep (run-time gating: does a
+ * queue row exist for this dep) and prdCreate.cjs's write-time validation
+ * (does a PRD exist for this dep at all). Both must agree on what a
+ * `dependsOn` entry resolves to, or a dep that validates at PRD-create time
+ * could still fail to block at run time (or vice versa) — so the matching
+ * rule lives here once, not copied into each caller.
+ *
+ * Resolution rule: exact slug match first; else bare-name match after
+ * stripping one leading `NN-` prefix — a human-authored `dependsOn:` can't
+ * know the `NN-` prefix the allocator will hand a sibling PRD.
+ */
+
+/** Strip one leading `NN-` prefix, if present. */
+function bareSlug(slug) {
+  return String(slug ?? '').replace(/^\d+-/, '');
+}
+
+/**
+ * Resolve `depSlug` against `candidateSlugs`: exact match wins outright;
+ * otherwise every candidate whose bare name matches. Returns a (possibly
+ * empty) array of matching candidate slugs.
+ */
+function resolveDepSlug(depSlug, candidateSlugs) {
+  if (candidateSlugs.includes(depSlug)) return [depSlug];
+  const bare = bareSlug(depSlug);
+  return candidateSlugs.filter((slug) => bareSlug(slug) === bare);
+}
+
+/**
+ * Levenshtein edit distance. O(n*m) in the two strings' lengths — fine here
+ * since it only ever runs over short slug strings (<= 60 chars, PRD_CREATE_SLUG_RE's
+ * cap) at PRD-create time, never in a hot/per-tick path.
+ */
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const prevRow = new Array(n + 1);
+  const curRow = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prevRow[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curRow[0] = i;
+    for (let j = 1; j <= n; j++) {
+      curRow[j] = a[i - 1] === b[j - 1]
+        ? prevRow[j - 1]
+        : 1 + Math.min(prevRow[j - 1], prevRow[j], curRow[j - 1]);
+    }
+    for (let j = 0; j <= n; j++) prevRow[j] = curRow[j];
+  }
+  return prevRow[n];
+}
+
+/**
+ * Nearest existing slugs to `depSlug` by bare-name edit distance, closest
+ * first, capped at `limit` — used to build an actionable "did you mean"
+ * error when a dependsOn entry resolves to nothing.
+ */
+function findNearMatches(depSlug, candidateSlugs, limit = 3) {
+  const depBare = bareSlug(depSlug);
+  return candidateSlugs
+    .map((slug) => ({ slug, dist: levenshtein(depBare, bareSlug(slug)) }))
+    .sort((a, b) => a.dist - b.dist)
+    .slice(0, limit)
+    .map((entry) => entry.slug);
+}
+
+module.exports = { bareSlug, resolveDepSlug, findNearMatches };

package/src/main/lib/epicWorktreeMerge.cjs

@@ -37,9 +37,9 @@ const { validatePath } = require('../config.cjs');
  * real conflict — never throws (integrateEpicBranch/cleanupEpicWorktree
  * never do either).
  */
-async function mergeEpicToMainViaIpc(cwd, epicId, branch, dir) {
+async function mergeEpicToMainViaIpc(cwd, epicId, branch, dir, carriedPaths) {
   validatePath(cwd);
-  const outcome = await integrateEpicBranch({ cwd, branch, epicId });
+  const outcome = await integrateEpicBranch({ cwd, branch, epicId, carriedPaths });
   if (!outcome.ok) {
     console.log(`[epicWorktreeMerge] ${epicId}: needs manual resolution (${outcome.reason})`);
     return { ok: false, status: 'needs_merge_resolution', reason: outcome.reason };
@@ -56,7 +56,7 @@ function registerEpicWorktreeMergeHandlers() {
   const { schemas: s, validated: v } = require('../ipcSchemas.cjs');
   ipcMain.handle(
     'promptSessions:merge-to-main',
-    v(s.promptSessionsMergeToMain, ({ cwd, epicId, branch, dir }) => mergeEpicToMainViaIpc(cwd, epicId, branch, dir)),
+    v(s.promptSessionsMergeToMain, ({ cwd, epicId, branch, dir, carriedPaths }) => mergeEpicToMainViaIpc(cwd, epicId, branch, dir, carriedPaths)),
   );
 }
 

package/src/main/lib/epicWorktreeMint.cjs

@@ -30,10 +30,10 @@ const { validatePath } = require('../config.cjs');
 /**
  * createEpicWorktreeViaIpc(cwd, epicId) → Promise<EpicWorktree | null>
  *
- * Returns the `worktree` field shape (`{ dir, branch, baseCwd, status }`)
- * ready to persist onto the Epic record on success, or `null` on any
- * failure — createEpicWorktree/createWorktree never throw, so this never
- * does either.
+ * Returns the `worktree` field shape (`{ dir, branch, baseCwd, status,
+ * carriedPaths }`) ready to persist onto the Epic record on success, or
+ * `null` on any failure — createEpicWorktree/createWorktree never throw, so
+ * this never does either.
  */
 async function createEpicWorktreeViaIpc(cwd, epicId) {
   validatePath(cwd);
@@ -42,7 +42,19 @@ async function createEpicWorktreeViaIpc(cwd, epicId) {
     console.log(`[epicWorktreeMint] ${epicId}: not isolated (${result.reason})`);
     return null;
   }
-  return { dir: result.dir, branch: result.branch, baseCwd: result.baseCwd, status: 'active' };
+  // carriedPaths (base-tree WIP carried into this worktree — PRD 1094) MUST
+  // survive onto the persisted record: it's the only way integrateEpicBranch
+  // (via epicWorktreeMerge.cjs) can later apply the carried-wip-only skip
+  // instead of attempting a doomed merge against the base tree's still-dirty
+  // paths. Dropping it here silently (as this used to) meant that skip never
+  // fired for Epics, only for scheduler jobs.
+  return {
+    dir: result.dir,
+    branch: result.branch,
+    baseCwd: result.baseCwd,
+    status: 'active',
+    ...(Array.isArray(result.carriedPaths) && result.carriedPaths.length ? { carriedPaths: result.carriedPaths } : {}),
+  };
 }
 
 function registerEpicWorktreeMintHandlers() {

package/src/main/lib/fixPlanSlug.cjs

@@ -0,0 +1,62 @@
+/**
+ * fixPlanSlug.cjs — single source of truth for recognizing a scheduler-
+ * authored fix-plan PRD (PRD 1131).
+ *
+ * `isFixPlanSlug`'s `/^\d+-fix-/` name test used to be treated as sufficient
+ * evidence on its own. But any PRD an agent or human authors through
+ * `scheduler_create_prd` whose title happens to kebab-case into a
+ * `fix-`-leading slug silently inherited every fix-plan special case
+ * (depth-capped auto-investigation, `commitGuardVerdict`'s zero-edit
+ * exemption) it never asked for — PRD 1126
+ * (`126-fix-plan-death-reopens-parent`, `createdVia: scheduler-api`) was
+ * wrongly stamped `investigationDepth: 2` before it ever ran and had to be
+ * withdrawn and re-slugged.
+ *
+ * A genuine fix plan is authored directly by scheduler.cjs's
+ * `spawnInvestigation` — a raw `Write`, never through `scheduler_create_prd`
+ * (see `guard-prd-writes.cjs`'s exemption) — so it never carries a
+ * `createdVia` stamp. Its prompt template also stamps an explicit
+ * `isFixPlan: true` frontmatter key so classification has a positive
+ * signal to check, not just an absence.
+ *
+ * `classifyDiscoveredFixPlan` is the ONE place a freshly-parsed PRD file
+ * (which has real `createdVia`/`isFixPlan` frontmatter) is turned into a
+ * boolean fix-plan verdict — `reconcile()` calls it once per newly
+ * discovered PRD and persists the verdict onto the queue row's `isFixPlan`
+ * field, so every later consumer reads that stamp instead of re-deriving it
+ * from the name. `resolveIsFixPlan` is what those consumers call: an
+ * explicit `true`/`false` on the row wins; a row with the field entirely
+ * absent (any queue.json row persisted before this change shipped) falls
+ * back to the legacy slug-only heuristic so live history is never
+ * re-classified.
+ */
+'use strict';
+
+function isFixPlanSlug(slug) {
+  return /^\d+-fix-/.test(slug);
+}
+
+/**
+ * Classify a freshly-parsed PRD file (real `createdVia`/`isFixPlan`
+ * frontmatter available). `createdVia` is checked FIRST and always wins —
+ * proof the PRD was authored through the sanctioned scheduler_create_prd API
+ * (a lower-trust path than spawnInvestigation's own raw write) must never be
+ * overridable by an `isFixPlan: true` stamp in the same file, even though no
+ * current write path can produce both on one file (see prdCreate.cjs's
+ * slug-refusal + guard-prd-writes.cjs's write-guard). Structural belt, not
+ * just relying on those two other files staying in sync.
+ */
+function classifyDiscoveredFixPlan({ isFixPlan, createdVia } = {}, slug) {
+  if (createdVia) return false;
+  if (isFixPlan === true) return true;
+  return isFixPlanSlug(slug);
+}
+
+/** Classify a queue-row job, honoring an already-persisted `isFixPlan` stamp over the slug. */
+function resolveIsFixPlan(slug, isFixPlan) {
+  if (isFixPlan === true) return true;
+  if (isFixPlan === false) return false;
+  return isFixPlanSlug(slug);
+}
+
+module.exports = { isFixPlanSlug, classifyDiscoveredFixPlan, resolveIsFixPlan };