claude-code-session-manager 0.78.0 → 0.80.0

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

@@ -0,0 +1,254 @@
+/**
+ * scheduler-resume-recovery.test.cjs — PRD 1111: resume-first recovery for a
+ * job parked in needs_review with verdict 'uncommitted_changes'. Before this
+ * feature, every such job went straight to spawnInvestigation (a cold-read
+ * fix-plan PRD authored by a FRESH session with no memory of the run it's
+ * diagnosing). This suite covers selectResumeRecoveryTarget's eligibility
+ * table, the --resume vs --session-id argv split (buildClaudeSpawnArgs), the
+ * preamble builder, the one-attempt bound, the SM_RESUME_RECOVERY_DISABLE
+ * kill-switch, and the two skip-gates (spawnInvestigation, selectAutoFixTargets).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-resume-recovery.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const {
+  selectResumeRecoveryTarget,
+  buildResumeRecoveryPreamble,
+  buildClaudeSpawnArgs,
+  selectAutoFixTargets,
+  spawnInvestigation,
+} = require('../scheduler.cjs');
+
+const savedDisable = process.env.SM_RESUME_RECOVERY_DISABLE;
+afterEach(() => {
+  if (savedDisable === undefined) delete process.env.SM_RESUME_RECOVERY_DISABLE;
+  else process.env.SM_RESUME_RECOVERY_DISABLE = savedDisable;
+});
+
+function baseJob(overrides = {}) {
+  return {
+    slug: '900-example',
+    status: 'needs_review',
+    verifierVerdict: 'uncommitted_changes',
+    sessionId: 'sess-abc-123',
+    uncommittedPaths: ['src/foo.js', 'src/bar.js'],
+    ...overrides,
+  };
+}
+
+// ---------- selectResumeRecoveryTarget eligibility table ----------
+
+test('selectResumeRecoveryTarget: eligible shape returns a resume decision', () => {
+  const target = selectResumeRecoveryTarget(baseJob());
+  expect(target).toEqual({
+    slug: '900-example',
+    sessionId: 'sess-abc-123',
+    dirtyPaths: ['src/foo.js', 'src/bar.js'],
+    salvagePatch: null,
+  });
+});
+
+test('selectResumeRecoveryTarget: carries salvagePatch through when present on the row', () => {
+  const target = selectResumeRecoveryTarget(baseJob({ salvagePatch: '/tmp/runs/x/900-example.uncommitted.patch' }));
+  expect(target.salvagePatch).toBe('/tmp/runs/x/900-example.uncommitted.patch');
+});
+
+const notNeedsReviewStatuses = ['pending', 'running', 'investigating', 'completed', 'failed', 'skipped'];
+for (const status of notNeedsReviewStatuses) {
+  test(`selectResumeRecoveryTarget: status=${status} → null`, () => {
+    expect(selectResumeRecoveryTarget(baseJob({ status }))).toBeNull();
+  });
+}
+
+const nonRecoverableVerdicts = [
+  'silent_no_op',
+  'pass_no_commit_already_shipped',
+  'pass_no_commit_prior_run_verified',
+  'transcript_errors',
+  'deps_unmet',
+  'halt',
+  'verify_unavailable',
+  'worktree_integration_failed',
+  'shared_tree_reverted',
+  undefined,
+];
+for (const verdict of nonRecoverableVerdicts) {
+  test(`selectResumeRecoveryTarget: verdict=${JSON.stringify(verdict)} → null`, () => {
+    expect(selectResumeRecoveryTarget(baseJob({ verifierVerdict: verdict }))).toBeNull();
+  });
+}
+
+test('selectResumeRecoveryTarget: missing sessionId → null', () => {
+  expect(selectResumeRecoveryTarget(baseJob({ sessionId: undefined }))).toBeNull();
+});
+
+test('selectResumeRecoveryTarget: empty-string sessionId → null', () => {
+  expect(selectResumeRecoveryTarget(baseJob({ sessionId: '' }))).toBeNull();
+});
+
+test('selectResumeRecoveryTarget: non-string sessionId → null', () => {
+  expect(selectResumeRecoveryTarget(baseJob({ sessionId: 12345 }))).toBeNull();
+});
+
+test('selectResumeRecoveryTarget: resumeRecoveryAttempted === true → null (bounded to one attempt)', () => {
+  expect(selectResumeRecoveryTarget(baseJob({ resumeRecoveryAttempted: true }))).toBeNull();
+});
+
+test('selectResumeRecoveryTarget: resumeRecoveryAttempted absent/false → still eligible', () => {
+  expect(selectResumeRecoveryTarget(baseJob({ resumeRecoveryAttempted: false }))).not.toBeNull();
+  expect(selectResumeRecoveryTarget(baseJob())).not.toBeNull();
+});
+
+test('selectResumeRecoveryTarget: no recorded dirty paths → null', () => {
+  expect(selectResumeRecoveryTarget(baseJob({ uncommittedPaths: [] }))).toBeNull();
+  expect(selectResumeRecoveryTarget(baseJob({ uncommittedPaths: undefined }))).toBeNull();
+});
+
+test('selectResumeRecoveryTarget: null/undefined job → null', () => {
+  expect(selectResumeRecoveryTarget(null)).toBeNull();
+  expect(selectResumeRecoveryTarget(undefined)).toBeNull();
+});
+
+test('selectResumeRecoveryTarget: SM_RESUME_RECOVERY_DISABLE=1 → null even for an otherwise-eligible job', () => {
+  process.env.SM_RESUME_RECOVERY_DISABLE = '1';
+  expect(selectResumeRecoveryTarget(baseJob())).toBeNull();
+});
+
+// ---------- --resume vs --session-id argv (buildClaudeSpawnArgs) ----------
+
+test('buildClaudeSpawnArgs: resume=true passes --resume <sessionId>, never --session-id', () => {
+  const args = buildClaudeSpawnArgs({ prompt: 'preamble text', model: 'sonnet', sessionId: 'sess-abc-123', resume: true });
+  expect(args).toContain('--resume');
+  expect(args[args.indexOf('--resume') + 1]).toBe('sess-abc-123');
+  expect(args).not.toContain('--session-id');
+});
+
+test('buildClaudeSpawnArgs: resume=false passes --session-id <sessionId>, never --resume', () => {
+  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'sonnet', sessionId: 'sess-fresh-456', resume: false });
+  expect(args).toContain('--session-id');
+  expect(args[args.indexOf('--session-id') + 1]).toBe('sess-fresh-456');
+  expect(args).not.toContain('--resume');
+});
+
+test('buildClaudeSpawnArgs: --model is always explicitly pinned, both modes', () => {
+  for (const resume of [true, false]) {
+    const args = buildClaudeSpawnArgs({ prompt: 'x', model: 'sonnet', sessionId: 'sid', resume });
+    const modelIdx = args.indexOf('--model');
+    expect(modelIdx).toBeGreaterThanOrEqual(0);
+    expect(args[modelIdx + 1]).toBe('sonnet');
+  }
+});
+
+// ---------- preamble content (buildResumeRecoveryPreamble) ----------
+
+test('buildResumeRecoveryPreamble: contains every recorded dirty path', () => {
+  const dirtyPaths = ['src/main/scheduler.cjs', 'session-manager-operations/scheduler/prds/900-example.md'];
+  const preamble = buildResumeRecoveryPreamble({ dirtyPaths, salvagePatch: null });
+  for (const p of dirtyPaths) {
+    expect(preamble).toContain(p);
+  }
+});
+
+test('buildResumeRecoveryPreamble: does NOT re-embed a PRD body passed in as an unrelated string', () => {
+  const prdBody = '# Goal\nSome long PRD body that must never appear in a resume preamble.\n## Acceptance criteria\n- [ ] thing';
+  const preamble = buildResumeRecoveryPreamble({ dirtyPaths: ['a.js'], salvagePatch: null });
+  expect(preamble).not.toContain(prdBody);
+  expect(preamble).not.toContain('Acceptance criteria');
+});
+
+test('buildResumeRecoveryPreamble: instructs verifying paths on disk, foreground gate, and commit', () => {
+  const preamble = buildResumeRecoveryPreamble({ dirtyPaths: ['a.js'], salvagePatch: null });
+  expect(preamble).toMatch(/verify/i);
+  expect(preamble).toMatch(/FOREGROUND/);
+  expect(preamble).toMatch(/commit/i);
+});
+
+test('buildResumeRecoveryPreamble: mentions the salvage patch path when present', () => {
+  const preamble = buildResumeRecoveryPreamble({ dirtyPaths: ['a.js'], salvagePatch: '/tmp/runs/x/900-example.uncommitted.patch' });
+  expect(preamble).toContain('/tmp/runs/x/900-example.uncommitted.patch');
+});
+
+// ---------- selectAutoFixTargets skips resume-eligible jobs ----------
+
+test('selectAutoFixTargets: excludes a job selectResumeRecoveryTarget accepts', () => {
+  const job = baseJob({ runId: 'run-1' });
+  const targets = selectAutoFixTargets([job], {
+    fixSlugExists: () => false,
+    resolveJobRunId: () => job.runId,
+  });
+  expect(targets).toEqual([]);
+});
+
+test('selectAutoFixTargets: still selects a needs_review job that is NOT resume-eligible (different verdict)', () => {
+  const job = baseJob({ runId: 'run-1', verifierVerdict: 'transcript_errors' });
+  const targets = selectAutoFixTargets([job], {
+    fixSlugExists: () => false,
+    resolveJobRunId: () => job.runId,
+  });
+  expect(targets.map((t) => t.slug)).toEqual([job.slug]);
+});
+
+test('selectAutoFixTargets: a resume-recovery-exhausted job (resumeRecoveryAttempted=true) falls through to normal auto-fix eligibility', () => {
+  const job = baseJob({ runId: 'run-1', resumeRecoveryAttempted: true });
+  const targets = selectAutoFixTargets([job], {
+    fixSlugExists: () => false,
+    resolveJobRunId: () => job.runId,
+  });
+  expect(targets.map((t) => t.slug)).toEqual([job.slug]);
+});
+
+// ---------- resume-then-fail: never a dead end ----------
+
+test('resume-then-fail: a job whose one resume attempt is spent falls through to the normal fix-plan path, not a dead end', () => {
+  // spawnResumeRecovery reuses spawnJob wholesale, so a resume run that
+  // itself re-parks in needs_review runs through the SAME finalize mutate as
+  // any other run — the only difference is resumeRecoveryAttempted is now
+  // true on the row (stamped atomically with the 'running' transition
+  // before the resume child ever spawned).
+  const jobAfterFailedResume = baseJob({ runId: 'run-2', resumeRecoveryAttempted: true });
+  // A second resume is refused...
+  expect(selectResumeRecoveryTarget(jobAfterFailedResume)).toBeNull();
+  // ...but the job is NOT stranded: it is offered for a fix-plan exactly
+  // like any other needs_review job, via the same gate spawnInvestigation's
+  // periodic caller (reverifyNeedsReview) consults.
+  const targets = selectAutoFixTargets([jobAfterFailedResume], {
+    fixSlugExists: () => false,
+    resolveJobRunId: () => jobAfterFailedResume.runId,
+  });
+  expect(targets.map((t) => t.slug)).toEqual([jobAfterFailedResume.slug]);
+});
+
+// ---------- spawnInvestigation's own resume-first guard ----------
+
+test('spawnInvestigation: a resume-eligible job is skipped before any fix-plan work (returns deferred:false immediately)', async () => {
+  const job = baseJob();
+  // A resume-eligible job trips the guard before spawnInvestigation ever
+  // touches the filesystem for runDir/investigationDepth lookups, so a
+  // nonexistent runDir is safe to pass here — proves the guard runs first.
+  const result = await spawnInvestigation(job, '/nonexistent/run/dir/for/this/test');
+  expect(result).toEqual({ deferred: false });
+});
+
+test('spawnInvestigation: resume-recovery-exhausted job (resumeRecoveryAttempted=true) is NOT skipped by the resume guard', async () => {
+  // slug matches the fix-plan pattern + investigationDepth beyond the cap so
+  // the NEXT gate (isFixPlanBeyondDepthCap) trips deterministically and
+  // returns before any fs/spawn work — proving the resume guard was passed
+  // through, not that this particular job happens to be safe to fully run.
+  const job = baseJob({ slug: '01-fix-example', resumeRecoveryAttempted: true, investigationDepth: 99 });
+  const result = await spawnInvestigation(job, '/nonexistent/run/dir/for/this/test');
+  expect(result).toEqual({ deferred: false });
+});
+
+test('SM_RESUME_RECOVERY_DISABLE=1: spawnInvestigation is NOT skipped by the resume guard for an otherwise-eligible job', async () => {
+  process.env.SM_RESUME_RECOVERY_DISABLE = '1';
+  const job = baseJob({ slug: '01-fix-example', investigationDepth: 99 });
+  // With the kill-switch on, selectResumeRecoveryTarget returns null, so the
+  // resume guard never fires; the job falls through to the NEXT gate
+  // (isFixPlanBeyondDepthCap, tripped here via investigationDepth: 99) —
+  // proving today's pre-feature behaviour is restored exactly.
+  const result = await spawnInvestigation(job, '/nonexistent/run/dir/for/this/test');
+  expect(result).toEqual({ deferred: false });
+});

package/src/main/__tests__/schedulerBatchRootBlocker.test.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+// PRD 1123 — a single row parked in `needs_review` (or `failed`/`skipped`)
+// several dependsOn hops down used to read as generic starvation: the picker
+// only ever named a held job's IMMEDIATE dep, which is very often just
+// another `pending` row, not the actual cause. These tests pin the root-
+// blocker walk: the reason must name the transitive ancestor that is itself
+// not blocked by anything, plus the count of jobs held behind it and its
+// status — and must terminate (not hang) on a dependsOn cycle.
+//
+// Run: timeout 120 npx vitest run src/main/__tests__/schedulerBatchRootBlocker.test.cjs
+
+const assert = require('node:assert/strict');
+const { pickForProject, DEFAULT_PROJECT_CWD } = require('../lib/schedulerBatch.cjs');
+
+const CWD = DEFAULT_PROJECT_CWD;
+
+function job(slug, status, extra = {}) {
+  return { slug, status, cwd: CWD, dependsOn: [], ...extra };
+}
+
+test('a 3-deep chain rooted at a needs_review row names the ROOT, not the middle link', () => {
+  const jobs = [
+    job('100-root', 'needs_review'),
+    job('101-middle', 'pending', { dependsOn: ['100-root'] }),
+    job('102-leaf', 'pending', { dependsOn: ['101-middle'] }),
+  ];
+  const { batch, reason, holds } = pickForProject(jobs, new Set(), 3);
+  assert.deepEqual(batch, []);
+  assert.match(reason, /depends-gate/);
+  // Names the root, not the immediate (middle) dep as the cause.
+  assert.match(reason, /root blocker 100-root/);
+  assert.match(reason, /needs_review/);
+  assert.match(reason, /is a QUESTION awaiting a human/);
+  // Both downstream jobs are counted as held behind the root.
+  assert.match(reason, /holding 2 job\(s\)/);
+  assert.match(reason, /101-middle/);
+  assert.match(reason, /102-leaf/);
+
+  const leafHold = holds.find((h) => h.slug === '102-leaf');
+  assert.equal(leafHold.dep, '101-middle'); // immediate dep still recorded
+  assert.equal(leafHold.rootSlug, '100-root'); // but the row also knows the root
+  assert.equal(leafHold.rootStatus, 'needs_review');
+});
+
+test('the same 3-deep chain rooted at a FAILED row names the root, not the middle link', () => {
+  const jobs = [
+    job('200-root', 'failed'),
+    job('201-middle', 'pending', { dependsOn: ['200-root'] }),
+    job('202-leaf', 'pending', { dependsOn: ['201-middle'] }),
+  ];
+  const { batch, reason, holds } = pickForProject(jobs, new Set(), 3);
+  assert.deepEqual(batch, []);
+  assert.match(reason, /root blocker 200-root/);
+  assert.match(reason, /\(failed\)/);
+  assert.match(reason, /holding 1 job\(s\)/); // only 202-leaf: 201-middle is caught by the shallow failed-dep bucket
+  assert.match(reason, /Reset or archive 200-root/);
+
+  const leafHold = holds.find((h) => h.slug === '202-leaf');
+  assert.equal(leafHold.rootSlug, '200-root');
+  assert.equal(leafHold.rootStatus, 'failed');
+  const middleHold = holds.find((h) => h.slug === '201-middle');
+  assert.equal(middleHold.rootSlug, '200-root');
+  assert.equal(middleHold.rootStatus, 'failed');
+});
+
+test('a 2-node dependsOn cycle is reported as its own reason, not a hang', () => {
+  const jobs = [
+    job('300-a', 'pending', { dependsOn: ['301-b'] }),
+    job('301-b', 'pending', { dependsOn: ['300-a'] }),
+  ];
+  const start = Date.now();
+  const { batch, reason } = pickForProject(jobs, new Set(), 3);
+  assert.ok(Date.now() - start < 5000, 'must terminate quickly, not hang');
+  assert.deepEqual(batch, []);
+  assert.match(reason, /CYCLE/);
+  assert.match(reason, /300-a/);
+  assert.match(reason, /301-b/);
+  // Reported exactly once, not once per member.
+  assert.equal((reason.match(/CYCLE/g) || []).length, 1);
+});
+
+test('no false stall reported when the gate is not the reason the batch is empty (slots exhausted)', () => {
+  const jobs = [job('400-a', 'pending'), job('401-b', 'pending')];
+  const { batch, reason } = pickForProject(jobs, new Set(), 0);
+  assert.deepEqual(batch, []);
+  assert.match(reason, /no slots free/);
+  assert.doesNotMatch(reason, /root blocker/);
+});
+
+test('no false stall reported when the gate is not the reason the batch is empty (project cap)', () => {
+  const prevCap = process.env.SM_PROJECT_JOB_CAP;
+  process.env.SM_PROJECT_JOB_CAP = '1';
+  try {
+    const jobs = [
+      job('402-running', 'running'),
+      job('403-pending', 'pending'),
+    ];
+    const { batch, reason } = pickForProject(jobs, new Set(['402-running']), 3);
+    assert.deepEqual(batch, []);
+    assert.match(reason, /project-cap/);
+    assert.doesNotMatch(reason, /root blocker/);
+  } finally {
+    if (prevCap === undefined) delete process.env.SM_PROJECT_JOB_CAP;
+    else process.env.SM_PROJECT_JOB_CAP = prevCap;
+  }
+});
+
+test('a running/pending-rooted chain reports no stall reason (expected to clear on its own)', () => {
+  const jobs = [
+    job('500-root', 'running'),
+    job('501-dependent', 'pending', { dependsOn: ['500-root'] }),
+  ];
+  const { batch, reason } = pickForProject(jobs, new Set(['500-root']), 3);
+  assert.deepEqual(batch, []);
+  assert.equal(reason, null);
+});

package/src/main/__tests__/uniquePrdNumbers.test.cjs

@@ -79,12 +79,24 @@ describe('pickForProject dependsOn eligibility (PRD 832)', () => {
     expect(res.batch.map((j) => j.slug)).toContain('851-next');
   });
 
-  it('a dep slug with NO queue row counts as done (retired to history)', () => {
+  it('a dep slug with NO queue row counts as done when found in history/archive (PRD 1122)', () => {
     const dependent = job('853-next', 'pending', 853, { dependsOn: ['852-archived-long-ago'] });
-    const res = pickForProject([dependent], new Set(), 3);
+    // Caller (scheduler.cjs's computeDepHistorySatisfaction) precomputes this
+    // Set from history.jsonl/prds-archived — pickForProject never does I/O.
+    const satisfiedSlugs = new Set(['852-archived-long-ago']);
+    const res = pickForProject([dependent], new Set(), 3, new Map(), satisfiedSlugs);
     expect(res.batch.map((j) => j.slug)).toContain('853-next');
   });
 
+  it('a dep slug with NO queue row and NO history/archive record HOLDS as unresolved (PRD 1122)', () => {
+    const dependent = job('853-next', 'pending', 853, { dependsOn: ['852-archived-long-ago'] });
+    const res = pickForProject([dependent], new Set(), 3);
+    expect(res.batch).toEqual([]);
+    expect(res.reason).toMatch(/unresolvable/);
+    expect(res.reason).toContain('853-next');
+    expect(res.reason).toContain('852-archived-long-ago');
+  });
+
   it('a FAILED dep holds the dependent with an explicit depends-gate reason', () => {
     const dep = job('854-base', 'failed', 854);
     const dependent = job('855-next', 'pending', 855, { dependsOn: ['854-base'] });

package/src/main/ipcSchemas.cjs

@@ -313,6 +313,13 @@ const NO_NEWLINE_RE = /^[^\r\n]*$/;
 // prdCreate.cjs's createPrd via prdAgentType.cjs's assertAgentTypeWritable —
 // this schema only enforces the name SHAPE.
 const PrdAgentTypeSchema = z.string().regex(PERSONA_NAME_RE, 'agent name must be lowercase, hyphenated (e.g. "dev-lead")');
+// Shared shape for a `dependsOn` slug entry — schedulerCreatePrd and
+// adminUpdatePrd (scheduler_update_prd, PRD 1124) must accept the exact same
+// slug shape or an update could write a dependsOn value create would have
+// rejected. Array-level constraints (`.max(20)`, `.optional()`) stay at each
+// call site since update also allows an explicit empty array to CLEAR the
+// dependency, which create has no reason to accept.
+const DepSlugSchema = z.string().min(1).max(160).regex(/^[A-Za-z0-9][\w.-]*$/);
 const schedulerCreatePrd = z.object({
   title: z.string().min(1).max(200).regex(NO_NEWLINE_RE, 'must not contain newlines'),
   // Optional (PRD: worktree-cwd Epic-lookup hazard) — when omitted, prdCreate.cjs's
@@ -332,7 +339,7 @@ const schedulerCreatePrd = z.object({
   parallelGroup: z.number().int().min(1).max(999999).optional(),
   // Explicit ordering (PRD 832): slugs that must complete before this PRD
   // becomes eligible. Written to frontmatter as `dependsOn: [a, b]`.
-  dependsOn: z.array(z.string().min(1).max(160).regex(/^[A-Za-z0-9][\w.-]*$/)).max(20).optional(),
+  dependsOn: z.array(DepSlugSchema).max(20).optional(),
   // An EXISTING Epic's promptSessionId (PRD 748) — NOT a PromptTicket.id.
   // ensureEpic() (epicMint.cjs) joins the Epic whose active-index.json
   // sessions key literally equals this value; the renderer only ever sends
@@ -455,6 +462,13 @@ const adminPrdFrontmatterPatch = z.object({
   // Opt-in exclusive-lease flag (PRD 1107) — patchable after creation too,
   // same as every other recognized key here.
   quietMachine: z.boolean().optional(),
+  // Explicit ordering (PRD 832), promoted to patchable by PRD 1124 — see
+  // prdFrontmatter.cjs's header. An explicit `[]` CLEARS the dependency
+  // (updatePrd's array-emptiness check skips writing the key at all); a
+  // non-empty array is validated write-time against the SAME resolver
+  // (depSlugResolve.cjs) scheduler_create_prd uses, so update and create
+  // can never disagree about what a dependsOn entry resolves to.
+  dependsOn: z.array(DepSlugSchema).max(20).optional(),
 });
 
 const adminUpdatePrd = z.object({

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

@@ -186,7 +186,7 @@ test('[job] integration is skipped (carried-wip-only) when the branch only commi
   await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: !outcome.ok });
 });
 
-test('[job] a branch that commits carried paths ALONGSIDE its own work still attempts integration normally (no silent drop)', async () => {
+test('[job] a branch that commits carried paths ALONGSIDE its own work auto-resolves the merge (PRD 1125: carried path is byte-identical duplicate, real work still lands)', async () => {
   const slug = 'test-slug-carried-plus-own-work';
   fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
   const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
@@ -198,16 +198,20 @@ test('[job] a branch that commits carried paths ALONGSIDE its own work still att
   git(['commit', '-q', '-m', 'job commit touching carried path + own work'], worktree.dir);
 
   const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug, carriedPaths: worktree.carriedPaths });
-  // The base tree still holds README.md dirty, so a real merge attempt here
-  // is expected to fail exactly like the existing worktreeIntegrationFailure
-  // path — branch preserved, not merged, not silently discarded.
-  expect(outcome.ok).toBe(false);
-  expect(outcome.reason).toBeTruthy();
-
-  const branches = git(['branch', '--list', worktree.branch], repoCwd);
-  expect(branches).toContain(worktree.branch.replace('sm-job/', ''));
+  // The base tree still holds README.md dirty, but its content is BYTE
+  // IDENTICAL to the branch's committed copy (the branch never edited it,
+  // only carried it through) — this is exactly the shape PRD 1125 teaches
+  // integrateBranch to auto-resolve: discard the duplicate, retry once, land
+  // the job's real new-file.txt commit too. Not the carried-wip-only
+  // shortcut (that only fires when the branch's ONLY changes are carried
+  // paths) — here the merge itself is what resolves.
+  expect(outcome.ok).toBe(true);
+  expect(outcome.integrated).toBe(true);
+  expect(outcome.autoResolved).toBe('identical_working_tree_duplicates');
+  expect(outcome.resolvedPaths).toEqual(['README.md']);
+  expect(fs.existsSync(path.join(repoCwd, 'new-file.txt'))).toBe(true);
 
-  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: !outcome.ok });
 });
 
 test('[job] a branch that ADDS its own edit on top of the carried content on the SAME path is never classified carried-wip-only (content-verify, not path-only)', async () => {
@@ -683,3 +687,118 @@ test('[job] reconcileWorktreesOnBoot logs a one-shot report line with reclaimed
     logSpy.mockRestore();
   }
 });
+
+// ──────────────────────────────────────────── PRD 1125: auto-resolve identical-duplicate merge blocks
+
+test('[job] integrateBranch auto-resolves when every blocking path (tracked + untracked) is byte-identical to the branch', async () => {
+  const slug = 'test-slug-identical-duplicates';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  // The job's own real work, committed on its branch.
+  fs.writeFileSync(path.join(worktree.dir, 'fileA'), 'shared-value\n', 'utf8');
+  fs.mkdirSync(path.join(worktree.dir, 'newdir'), { recursive: true });
+  fs.writeFileSync(path.join(worktree.dir, 'newdir', 'fileU'), 'untracked-shared-value\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job commit'], worktree.dir);
+
+  // The shared main tree independently ends up with the SAME bytes on both
+  // a tracked path (dirty, uncommitted) and an untracked path — exactly the
+  // 2026-09-06 starry-night-ships incident shape: a prior in-place run left
+  // these duplicates behind uncommitted.
+  fs.writeFileSync(path.join(repoCwd, 'fileA'), 'shared-value\n', 'utf8');
+  fs.mkdirSync(path.join(repoCwd, 'newdir'), { recursive: true });
+  fs.writeFileSync(path.join(repoCwd, 'newdir', 'fileU'), 'untracked-shared-value\n', 'utf8');
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(true);
+  expect(outcome.integrated).toBe(true);
+  expect(outcome.mergeCommit ?? outcome.fastForward).toBeTruthy();
+  expect(outcome.autoResolved).toBe('identical_working_tree_duplicates');
+  expect(outcome.resolvedPaths.sort()).toEqual(['fileA', 'newdir/fileU'].sort());
+
+  expect(fs.readFileSync(path.join(repoCwd, 'fileA'), 'utf8')).toBe('shared-value\n');
+  expect(fs.readFileSync(path.join(repoCwd, 'newdir', 'fileU'), 'utf8')).toBe('untracked-shared-value\n');
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: !outcome.ok });
+});
+
+test('[job] integrateBranch does NOT auto-resolve when one blocking path differs from the branch — same reason as today', async () => {
+  const slug = 'test-slug-one-differing-path';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  fs.writeFileSync(path.join(worktree.dir, 'fileA'), 'branch-value\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job commit'], worktree.dir);
+
+  // Main tree's dirty copy diverges from the branch's committed content —
+  // real information is at risk, so this must NOT be discarded.
+  fs.writeFileSync(path.join(repoCwd, 'fileA'), 'different-local-value\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(fs.readFileSync(path.join(repoCwd, 'fileA'), 'utf8')).toBe('different-local-value\n');
+  expect(git(['status', '--porcelain'], repoCwd).trim()).not.toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch falls through to today\'s failure when stderr has no parseable blocking-path block (a genuine content conflict)', async () => {
+  const slug = 'test-slug-unparseable-stderr';
+  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);
+
+  // A committed (not dirty) diverging edit on the main tree produces git's
+  // ordinary "CONFLICT (content)" stderr shape, not the "would be
+  // overwritten" block parseBlockingMergePaths looks for.
+  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.reason).toMatch(/merge failed \(likely a real content conflict\)/);
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch aborts cleanly when the single retry also fails on a genuine conflict elsewhere', async () => {
+  const slug = 'test-slug-retry-fails';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  // The branch's own real work: extends fileA (existing, tracked since
+  // initRepo's README.md commit doesn't cover it — add it fresh here) and
+  // ADDS a brand-new fileB.txt.
+  fs.writeFileSync(path.join(worktree.dir, 'fileA'), 'shared-value\n', 'utf8');
+  fs.writeFileSync(path.join(worktree.dir, 'fileB.txt'), 'branch B change\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job commit: fileA + fileB'], worktree.dir);
+
+  // Main tree independently ADDS the SAME path with DIFFERENT content — a
+  // genuine "both added, diverging content" conflict on fileB.txt.
+  fs.writeFileSync(path.join(repoCwd, 'fileB.txt'), 'base B change\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main tree diverges fileB'], repoCwd);
+  // ...and ALSO leaves fileA dirty with content byte-identical to the branch
+  // — the one blocking path the initial merge attempt refuses on, and the
+  // one the auto-resolve retry successfully discards.
+  fs.writeFileSync(path.join(repoCwd, 'fileA'), 'shared-value\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\)/);
+  // The retry's half-applied merge must be aborted, not left mid-merge.
+  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 });
+});