claude-code-session-manager 0.37.2 → 0.38.1

package/plugins/session-manager-dev/skills/pr-signal/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: pr-signal
+description: >-
+  Request or re-request a reviewer on one PR on the current project's repo — the ONLY
+  step in the PR flow that contacts a person. Deliberately separate from pr-review-sweep
+  and meant to be invoked rarely — most projects don't tag reviewers often. Requires the
+  user's explicit, fresh, per-PR approval every time — a prior approval never carries
+  forward, and CI must be green at the moment of signaling, not just when approval was
+  given. Use only when the user explicitly names a PR number and says to
+  request/ping/notify the reviewer, or approves signaling in response to a
+  pr-review-sweep report.
+---
+
+# pr-signal — the one step that contacts a reviewer (rare, gated)
+
+Global, project-agnostic — works against whatever repo the current project's `gh` remote
+points to. Input: a PR whose queued PRDs have all landed and whose threads
+`pr-review-sweep:land-and-resolve` has replied to and resolved (CI green) — plus the user's
+explicit approval for this specific PR number, given in this conversation, not inherited
+from an earlier one. If the project has its own reviewer-contact policy doc (e.g. sigma's
+`docs/pr-review-workflow.local.md`), read it for repo-specific nuance — reviewer identity,
+cadence norms — but the approval-per-PR and CI-green-at-signal-time gates below are hard
+constants regardless of what a project's doc says.
+
+**This skill runs far less often than the rest of the flow.** Most PRs on this repo don't need
+an explicit re-request — a push alone re-triggers review for an already-requested reviewer, and
+this team doesn't like being tagged unnecessarily. Only invoke this when the user actually asks
+for it, by PR number.
+
+## Steps
+
+1. **Verify the gate, don't assume it from a report given earlier in the conversation:**
+   - The PR is still open (`gh pr view <n> --json state,mergedAt`) — a merged/closed PR gets
+     no signal; report the state change instead.
+   - Every review thread is resolved (re-check now via GraphQL `reviewThreads.isResolved` — a
+     `pr-review-sweep:land-and-resolve` report from even a few minutes ago can be stale if
+     anything else touched the PR, and a new comment that arrived since means the PR goes back
+     through `pr-review-sweep:classify`, not to a signal).
+   - CI is green **right now** — re-run `gh pr checks <n> --repo "$(gh repo view --json nameWithOwner -q .nameWithOwner)"` immediately
+     before acting. An approval given while CI was green does not survive CI going red in
+     between (a later push, a flaky rerun). If CI is red at signal-time, stop and report it —
+     never signal on a stale approval, and never solicit approval on a PR that's currently
+     CI-red in the first place.
+   - No review is already outstanding (requested, not yet dismissed by a later push) — if one
+     is, the push itself was already the signal; do not re-request
+     ([[no-reviewer-ping-without-approval]] / [[reviewers-dont-spam]]).
+   - The user's approval is for **this PR number, in this conversation** — a blanket "yes,
+     signal when ready" said about a different PR, or said before this session, does not count.
+
+2. **If any gate check fails**, stop and report exactly which one — don't ask "should I signal
+   now?" as a throwaway line and proceed anyway.
+
+3. **If every gate check passes**, request the reviewer:
+   ```bash
+   gh pr edit <number> --repo "$(gh repo view --json nameWithOwner -q .nameWithOwner)" --add-reviewer <reviewer>
+   ```
+   If `gh pr edit` fails with the known "Projects (classic)" GraphQL deprecation error on this
+   repo, fall back to
+   `gh api repos/$(gh repo view --json nameWithOwner -q .nameWithOwner)/pulls/<n>/requested_reviewers -f "reviewers[]=<reviewer>"` —
+   and send it exactly once; verify via `gh pr view <n> --json reviewRequests` rather than
+   retrying blind (a retry after an ambiguous failure is how a double-ping happens).
+   Do not add a "ready for re-review" comment or @-mention on top of the request — the request
+   itself is the signal; a comment on top of it is the over-notification this skill exists to
+   avoid.
+
+4. **Report** the PR as signaled, and loop back to `project-status-local` to pick up the new
+   state on its next run.

package/src/main/__tests__/chat-cancel-terminal.test.cjs

@@ -75,6 +75,37 @@ test('cancelling an ACTIVE run broadcasts a terminal event (unsticks the UI)', a
   assert.match(terminal[0].payload.message, /cancel/i, 'message names the cancellation');
 });
 
+test('cancel() resolves only AFTER the terminal broadcast fires, not immediately on SIGTERM (PRD 718)', async () => {
+  // Order-of-events assertion (not timing-based — a real SIGTERM can be fast
+  // enough on a lightweight stub child that a fixed-delay race would flake).
+  const order = [];
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: {
+      isDestroyed: () => false,
+      send: (channel, payload) => {
+        if (isTerminal(channel) && payload.tabId === 'T2') order.push('terminal');
+      },
+    },
+  });
+
+  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'hello', cwd: process.cwd(), resume: false });
+
+  for (let i = 0; i < 6; i++) await tick();
+
+  await cr.cancel('T2').then(() => order.push('resolved'));
+
+  assert.deepEqual(order, ['terminal', 'resolved'], 'cancel() resolves strictly after the terminal broadcast');
+});
+
+test('cancel() on a tab with no in-flight or waiting run resolves immediately (no-op)', async () => {
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: { isDestroyed: () => false, send: () => {} },
+  });
+  await cr.cancel('no-such-tab'); // must resolve, not hang
+});
+
 function isTerminal(channel) {
   return (
     channel === 'chat:run:complete' ||

package/src/main/__tests__/chat-exit-close-race.test.cjs

@@ -0,0 +1,140 @@
+/**
+ * chat-exit-close-race.test.cjs — regression for the exit/close race that
+ * silently dropped a pure-text-only final turn (PRD 716).
+ *
+ * Bug: the terminal-event fallback was wired to `child.on('exit', ...)`
+ * instead of `child.on('close', ...)`. Node only guarantees all buffered
+ * stdout 'data' events have been delivered by 'close', not 'exit' — 'exit'
+ * can fire before the final stdout chunk (last assistant text + terminating
+ * `result` line) reaches the parent's 'data' handler. When that happened,
+ * the exit fallback ran first, set the one-shot terminalSent latch, and
+ * broadcast a misleading chat:run:error. The real result line then parsed
+ * moments later, but emitTerminal silently no-op'd and the genuine
+ * chat:run:complete was dropped.
+ *
+ * Fix: use `child.on('close', ...)` for the fallback so it only fires once
+ * Node guarantees stdout is fully drained — a real result event that arrives
+ * (even "late", right up against process exit) always wins.
+ *
+ * This test mocks node:child_process.spawn so it can deterministically
+ * reproduce the exact race ordering (exit fires, THEN the final stdout chunk
+ * arrives, THEN close fires) rather than relying on real OS/pipe timing,
+ * which is not reliably reproducible from a real child process.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/chat-exit-close-race.test.cjs
+ */
+
+'use strict';
+
+delete process.env.SM_CHAT_CONCURRENCY;
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const EventEmitter = require('node:events');
+const cp = require('node:child_process');
+
+// Replace spawn BEFORE chatRunner.cjs is first required, so the module's
+// top-level `const { spawn } = require('node:child_process')` destructuring
+// captures this mock instead of the real implementation.
+const originalSpawn = cp.spawn;
+let nextChild = null;
+cp.spawn = () => {
+  const child = new EventEmitter();
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.pid = 424242;
+  child.kill = () => {};
+  nextChild = child;
+  return child;
+};
+
+const cr = require('../chatRunner.cjs');
+
+const tick = () => new Promise((r) => setImmediate(r));
+
+test('a final-text-only turn whose stdout chunk lands after exit still surfaces chat:run:complete', async () => {
+  nextChild = null;
+  const events = [];
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: {
+      isDestroyed: () => false,
+      send: (channel, payload) => events.push({ channel, payload }),
+    },
+  });
+
+  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'show me a sample post', cwd: process.cwd(), resume: false });
+
+  for (let i = 0; i < 20 && !nextChild; i++) await tick();
+  const child = nextChild;
+  assert.ok(child, 'spawn should have been invoked');
+
+  const text = 'Here is your sample post, all in one go.';
+  const lines =
+    JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text }] } }) +
+    '\n' +
+    JSON.stringify({ type: 'result', subtype: 'success', result: text }) +
+    '\n';
+
+  // The exact race: 'exit' fires first (process already gone from the OS's
+  // perspective), the final stdout chunk is delivered to the 'data' handler
+  // only after that, and 'close' — which Node guarantees fires after all
+  // stdout data has been delivered — fires last.
+  child.emit('exit', 0, null);
+  child.stdout.emit('data', Buffer.from(lines));
+  child.emit('close', 0, null);
+
+  await tick();
+  await tick();
+
+  const terminal = events.filter((e) => isTerminal(e.channel));
+  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
+  assert.equal(
+    terminal[0].channel,
+    'chat:run:complete',
+    'the real result event must win over the generic exit-fallback error',
+  );
+  assert.equal(terminal[0].payload.finalMessage, text);
+});
+
+test('a crashed process with no result event ever emitted still fires the fallback chat:run:error', async () => {
+  nextChild = null;
+  const events = [];
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: {
+      isDestroyed: () => false,
+      send: (channel, payload) => events.push({ channel, payload }),
+    },
+  });
+
+  cr.run({ tabId: 'T3', sessionId: 'S3', prompt: 'anything', cwd: process.cwd(), resume: false });
+
+  for (let i = 0; i < 20 && !nextChild; i++) await tick();
+  const child = nextChild;
+  assert.ok(child, 'spawn should have been invoked');
+
+  // Crashes with no stdout at all — 'close' is the only event that fires.
+  child.emit('close', 1, null);
+
+  await tick();
+  await tick();
+
+  const terminal = events.filter((e) => isTerminal(e.channel));
+  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
+  assert.equal(terminal[0].channel, 'chat:run:error', 'a crash with no result surfaces as an error turn');
+  assert.match(terminal[0].payload.message, /process exited without a result event/);
+});
+
+function isTerminal(channel) {
+  return (
+    channel === 'chat:run:complete' ||
+    channel === 'chat:run:needs-input' ||
+    channel === 'chat:run:error'
+  );
+}
+
+test.after(() => {
+  cp.spawn = originalSpawn;
+  delete process.env.SM_CHAT_CONCURRENCY;
+});

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

@@ -0,0 +1,101 @@
+/**
+ * classifyPromptTicket.test.cjs — unit tests for the PromptTicket
+ * inline-vs-develop classifier (PRD 749).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/classifyPromptTicket.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach } from 'vitest';
+const { EventEmitter } = require('node:events');
+const {
+  classifyPromptTicket,
+  parseVerdict,
+  __setSpawnForTest,
+} = require('../lib/classifyPromptTicket.cjs');
+
+beforeEach(() => {
+  __setSpawnForTest(null); // restore real spawn between tests
+});
+
+test('parseVerdict returns "develop" only when the raw text contains the word develop', () => {
+  expect(parseVerdict('develop')).toBe('develop');
+  expect(parseVerdict('  Develop  ')).toBe('develop');
+  expect(parseVerdict('inline')).toBe('inline');
+  expect(parseVerdict('')).toBe('inline');
+  expect(parseVerdict(undefined)).toBe('inline');
+});
+
+function fakeChild() {
+  const child = new EventEmitter();
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.kill = () => {};
+  return child;
+}
+
+test('classifyPromptTicket resolves "develop" for a complex sample prompt (stubbed spawn)', async () => {
+  __setSpawnForTest(() => {
+    const child = fakeChild();
+    setTimeout(() => {
+      child.stdout.emit('data', Buffer.from('develop'));
+      child.emit('close', 0);
+    }, 0);
+    return child;
+  });
+
+  const verdict = await classifyPromptTicket('Build a full multi-tab prompt-queue feature with PRD decomposition');
+  expect(verdict).toBe('develop');
+});
+
+test('classifyPromptTicket resolves "inline" for a quick sample prompt (stubbed spawn)', async () => {
+  __setSpawnForTest(() => {
+    const child = fakeChild();
+    setTimeout(() => {
+      child.stdout.emit('data', Buffer.from('inline'));
+      child.emit('close', 0);
+    }, 0);
+    return child;
+  });
+
+  const verdict = await classifyPromptTicket('what time is it');
+  expect(verdict).toBe('inline');
+});
+
+test('classifyPromptTicket fails safe to "inline" when the child process errors', async () => {
+  __setSpawnForTest(() => {
+    const child = fakeChild();
+    setTimeout(() => child.emit('error', new Error('spawn failed')), 0);
+    return child;
+  });
+
+  const verdict = await classifyPromptTicket('anything');
+  expect(verdict).toBe('inline');
+});
+
+test('classifyPromptTicket spawns with a pinned model, argv array (no shell string), and closed stdin', async () => {
+  let capturedBin;
+  let capturedArgs;
+  let capturedOpts;
+  __setSpawnForTest((bin, args, opts) => {
+    capturedBin = bin;
+    capturedArgs = args;
+    capturedOpts = opts;
+    const child = fakeChild();
+    setTimeout(() => {
+      child.stdout.emit('data', Buffer.from('inline'));
+      child.emit('close', 0);
+    }, 0);
+    return child;
+  });
+
+  await classifyPromptTicket('hello');
+
+  expect(typeof capturedBin).toBe('string');
+  expect(Array.isArray(capturedArgs)).toBe(true);
+  expect(capturedArgs).toContain('--model');
+  expect(capturedArgs[capturedArgs.indexOf('--model') + 1]).toBe('sonnet');
+  expect(capturedOpts.stdio[0]).toBe('ignore');
+  expect(capturedOpts.shell).toBeFalsy();
+});

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

@@ -0,0 +1,70 @@
+/**
+ * exchangesPromptId.test.cjs — recordExchange() round-trips the optional
+ * promptId field (PRD 749). Separate file from exchanges.test.cjs (which
+ * runs under node:test, not vitest) so this is picked up by
+ * `npx vitest run` per this repo's test:unit convention.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/exchangesPromptId.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+
+let tmpHome;
+let origHome;
+
+beforeAll(() => {
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'exchanges-promptid-test-'));
+  origHome = process.env.HOME;
+  process.env.HOME = tmpHome;
+});
+
+afterAll(async () => {
+  process.env.HOME = origHome;
+  await fsp.rm(tmpHome, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  // Stub summarize.cjs to avoid any network calls, and clear the modules
+  // that cache HOME-derived paths so each test sees the tmp HOME.
+  const summarizePath = require.resolve('../lib/summarize.cjs');
+  delete require.cache[summarizePath];
+  require.cache[summarizePath] = {
+    id: summarizePath,
+    filename: summarizePath,
+    loaded: true,
+    exports: { summarize: async () => ({ summary: 'ok', model: 'claude-haiku-4-5' }) },
+  };
+  delete require.cache[require.resolve('../exchanges.cjs')];
+  delete require.cache[require.resolve('../config.cjs')];
+  delete require.cache[require.resolve('../lib/encodeCwd.cjs')];
+});
+
+test('recordExchange persists promptId when supplied', async () => {
+  const { recordExchange } = require('../exchanges.cjs');
+  const { encodeCwd } = require('../lib/encodeCwd.cjs');
+
+  const cwd = '/home/user/promptid-project';
+  await recordExchange({ sessionId: 's1', cwd, prompt: 'do X', result: 'done', promptId: 'ticket-abc-123' });
+
+  const logPath = path.join(tmpHome, '.claude', 'knowledge-log', 'exchanges', `${encodeCwd(cwd)}.jsonl`);
+  const record = JSON.parse((await fsp.readFile(logPath, 'utf8')).trim());
+  expect(record.promptId).toBe('ticket-abc-123');
+});
+
+test('recordExchange omits promptId when not supplied (no backfill/synthesis)', async () => {
+  const { recordExchange } = require('../exchanges.cjs');
+  const { encodeCwd } = require('../lib/encodeCwd.cjs');
+
+  const cwd = '/home/user/no-promptid-project';
+  await recordExchange({ sessionId: 's2', cwd, prompt: 'do Y', result: 'done' });
+
+  const logPath = path.join(tmpHome, '.claude', 'knowledge-log', 'exchanges', `${encodeCwd(cwd)}.jsonl`);
+  const record = JSON.parse((await fsp.readFile(logPath, 'utf8')).trim());
+  expect('promptId' in record).toBe(false);
+});

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

@@ -85,6 +85,23 @@ test('buildPrdBody omits parallelGroup frontmatter key when not supplied', () =>
   expect(!/parallelGroup:/.test(body)).toBeTruthy();
 });
 
+test('buildPrdBody writes sourcePromptId into frontmatter when supplied (PRD 749 traceability)', () => {
+  const body = buildPrdBody({
+    title: 't', cwd: '~/x', estimateMinutes: 5, goal: 'g',
+    acceptanceCriteria: ['a'], implementationNotes: 'n',
+    sourcePromptId: 'ticket-abc-123',
+  });
+  expect(body).toMatch(/sourcePromptId: ticket-abc-123/);
+});
+
+test('buildPrdBody omits sourcePromptId frontmatter key when not supplied', () => {
+  const body = buildPrdBody({
+    title: 't', cwd: '~/x', estimateMinutes: 5, goal: 'g',
+    acceptanceCriteria: ['a'], implementationNotes: 'n',
+  });
+  expect(!/sourcePromptId:/.test(body)).toBeTruthy();
+});
+
 test('readStandards result is byte-identical to the on-disk file (single source of truth)', async () => {
   const onDisk = fs.readFileSync(
     path.join(__dirname, '..', '..', '..', 'plugins', 'session-manager-dev', 'skills', 'develop', 'standards.md'),
@@ -320,3 +337,20 @@ test('POST /admin/scheduler/create-prd honors an explicit slug + parallelGroup i
     await admin.stop();
   }
 });
+
+test('POST /admin/scheduler/create-prd with sourcePromptId writes it into the created PRD frontmatter', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ slug: 'from-a-ticket', parallelGroup: 888, sourcePromptId: 'ticket-xyz-789' }),
+    });
+    expect(res.status).toBe(200);
+    const written = fs.readFileSync(path.join(prdsDir, '888-from-a-ticket.md'), 'utf8');
+    expect(written).toMatch(/sourcePromptId: ticket-xyz-789/);
+  } finally {
+    await admin.stop();
+  }
+});

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

@@ -0,0 +1,65 @@
+/**
+ * prdParserSourcePromptId.test.cjs — parsePrdRaw() tolerates both presence
+ * and absence of the optional `sourcePromptId` frontmatter key (PRD 749).
+ * Additive-only: PRDs written before this field existed must still parse
+ * identically (no required-field regression).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdParserSourcePromptId.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const { parsePrdRaw, _resetCache } = require('../scheduler/prdParser.cjs');
+
+function mkTmpPrdsDir() {
+  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-sourceprompt-'));
+}
+
+test('parsePrdRaw extracts sourcePromptId when present in frontmatter', async () => {
+  const dir = await mkTmpPrdsDir();
+  _resetCache();
+  const filePath = path.join(dir, '1-with-source.md');
+  await fsp.writeFile(filePath, [
+    '---',
+    'title: Has a source ticket',
+    'cwd: ~/Projects/session-manager',
+    'estimateMinutes: 10',
+    'sourcePromptId: ticket-xyz-789',
+    '---',
+    '# Goal',
+    '',
+    'Do the thing.',
+    '',
+  ].join('\n'));
+
+  const parsed = await parsePrdRaw(filePath);
+  expect(parsed.sourcePromptId).toBe('ticket-xyz-789');
+  expect(parsed.title).toBe('Has a source ticket');
+});
+
+test('parsePrdRaw returns null sourcePromptId for a PRD authored before this field existed', async () => {
+  const dir = await mkTmpPrdsDir();
+  _resetCache();
+  const filePath = path.join(dir, '2-legacy.md');
+  await fsp.writeFile(filePath, [
+    '---',
+    'title: Legacy PRD, no sourcePromptId',
+    'cwd: ~/Projects/session-manager',
+    'estimateMinutes: 5',
+    '---',
+    '# Goal',
+    '',
+    'Do the other thing.',
+    '',
+  ].join('\n'));
+
+  const parsed = await parsePrdRaw(filePath);
+  expect(parsed.sourcePromptId).toBe(null);
+  expect(parsed.title).toBe('Legacy PRD, no sourcePromptId');
+  expect(parsed.cwd).toBe(path.join(os.homedir(), 'Projects', 'session-manager'));
+});

package/src/main/__tests__/scheduler-committed-in-window.test.cjs

@@ -61,3 +61,67 @@ test('committedInWindow returns false when the window covers no commit', async (
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
+
+// Reproduces the sigma PRD 713 incident: a commit made+pushed from an
+// isolated worktree checkout that shares the run's remote but not job.cwd's
+// local refs — e.g. `git worktree add /tmp/foo` followed by `git worktree
+// remove` clears the worktree's local branch, leaving the commit reachable
+// in job.cwd only via a remote-tracking ref that hasn't been fetched yet.
+// Modeled here as a second, independent clone of the shared remote (rather
+// than a literal `git worktree add`, which shares job.cwd's .git store and
+// so opportunistically updates job.cwd's remote-tracking ref on push,
+// masking the staleness this test needs to exercise) — the observable
+// symptom is identical: job.cwd's remote-tracking ref is stale until fetched.
+test('committedInWindow sees a commit pushed from an isolated checkout, only reachable via a stale remote-tracking ref', async () => {
+  const bareDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-bare-'));
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-cwd-'));
+  const worktreeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-wt-'));
+  try {
+    git(bareDir, ['init', '-q', '--bare']);
+
+    const seedDir = makeRepo();
+    try {
+      git(seedDir, ['push', bareDir, 'HEAD:refs/heads/main']);
+      // Without an explicit default branch, the bare repo's symbolic HEAD can
+      // point at a nonexistent ref (e.g. 'master'), which makes the clone
+      // below check out no local branch at all — set it explicitly.
+      git(bareDir, ['symbolic-ref', 'HEAD', 'refs/heads/main']);
+    } finally {
+      fs.rmSync(seedDir, { recursive: true, force: true });
+    }
+
+    git(cwd, ['clone', '-q', bareDir, '.']);
+    git(cwd, ['config', 'user.email', 'test@example.com']);
+    git(cwd, ['config', 'user.name', 'Test']);
+
+    const startedAt = new Date().toISOString();
+
+    // Simulate the PRD's own isolated-checkout workflow: a separate clone of
+    // the same shared remote, a commit there, a push back to that remote —
+    // job.cwd never touches this checkout and never fetches after the push.
+    git(worktreeDir, ['clone', '-q', bareDir, '.']);
+    git(worktreeDir, ['config', 'user.email', 'test@example.com']);
+    git(worktreeDir, ['config', 'user.name', 'Test']);
+    git(worktreeDir, ['checkout', '-q', '-b', 'temp-merge-branch']);
+    fs.writeFileSync(path.join(worktreeDir, 'feature.txt'), 'feature\n');
+    git(worktreeDir, ['add', '.']);
+    git(worktreeDir, ['commit', '-q', '-m', 'feature commit from isolated worktree']);
+    git(worktreeDir, ['push', 'origin', 'temp-merge-branch']);
+
+    const finishedAt = new Date(Date.now() + 1000).toISOString();
+
+    // Precondition: without a fetch, job.cwd genuinely cannot see the commit —
+    // this is what made committedInWindow's old bare `git log --all` blind to it.
+    expect(() => git(cwd, ['log', '--all', '--format=%H', '--grep=feature commit from isolated worktree']))
+      .not.toThrow();
+    const beforeFetch = git(cwd, ['log', '--all', '--format=%H', '--grep=feature commit from isolated worktree']);
+    expect(beforeFetch).toBe('');
+
+    const result = await committedInWindow(cwd, startedAt, finishedAt);
+    expect(result).toBe(true);
+  } finally {
+    fs.rmSync(bareDir, { recursive: true, force: true });
+    fs.rmSync(cwd, { recursive: true, force: true });
+    fs.rmSync(worktreeDir, { recursive: true, force: true });
+  }
+});