claude-code-session-manager 0.39.0 → 0.39.2

package/src/main/__tests__/scheduler-commit-guard-noop.test.cjs

@@ -0,0 +1,126 @@
+/**
+ * scheduler-commit-guard-noop.test.cjs — commitGuardVerdict must not flag a
+ * legitimate no-op job (a truthful SCHEDULER_VERDICT: PASS, no commit, whose
+ * own verifier verdict already independently proved the no-op is correct)
+ * for dirt a CONCURRENT actor (e.g. an interactive /process-feedback session
+ * writing new PRD .md files into the same repo) left in the working tree.
+ *
+ * Reproduces the confirmed 2026-07-31 incidents: job
+ * 655-needs-review-rca-feedback-hook (verdict pass_no_commit_already_shipped)
+ * was flagged uncommitted_changes for a file an interactive session wrote,
+ * and job 672-fix-feedback-session-manager similarly. Before this fix, the
+ * commit-guard had no exemption for a job whose verifier verdict was already
+ * a proven no-op (COMPLETED_EQUIVALENT_VERDICTS) — only for jobSelfCommitted
+ * or siblingRunning.
+ *
+ * Also guards the inverse: a REAL leftover-work case (no legitimate no-op
+ * verdict, no sibling, no self-commit) must still be flagged — this fix must
+ * not weaken the guard for genuine finish-protocol violations.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-commit-guard-noop.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { commitGuardVerdict } = require('../scheduler.cjs');
+
+test('commitGuardVerdict: legitimate no-op verdict (pass_no_commit_already_shipped) + concurrent dirt → no flag (655 incident)', () => {
+  const verifyResult = {
+    verdict: 'pass_no_commit_already_shipped',
+    reason: 'SCHEDULER_VERDICT: PASS with no commit, but every PRD-named deliverable path is already tracked',
+    downgradeTo: null,
+  };
+  const verdict = commitGuardVerdict({
+    newlyDirty: ['session-manager-operations/scheduler/prds/816-vitest-register-runverify-test.md'],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: true,
+    verifyResult,
+  });
+  expect(verdict).toBeNull();
+});
+
+test('commitGuardVerdict: legitimate no-op verdict (pass_no_commit_prior_run_verified) + concurrent dirt across multiple files → no flag (672 incident)', () => {
+  const verifyResult = {
+    verdict: 'pass_no_commit_prior_run_verified',
+    reason: 'SCHEDULER_VERDICT: PASS with no commit, but a prior run of this slug landed a commit already',
+    downgradeTo: null,
+  };
+  const verdict = commitGuardVerdict({
+    newlyDirty: [
+      'session-manager-operations/feedback/processed/a.md',
+      'session-manager-operations/feedback/processed/b.md',
+      'session-manager-operations/scheduler/prds/816-vitest-register-runverify-test.md',
+    ],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: true,
+    verifyResult,
+  });
+  expect(verdict).toBeNull();
+});
+
+test('commitGuardVerdict: REAL leftover work (no legitimate no-op, no sibling, no self-commit) still flags uncommitted_changes', () => {
+  const verdict = commitGuardVerdict({
+    newlyDirty: ['src/main/someFeature.cjs'],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    verifyResult: null,
+  });
+  expect(verdict).not.toBeNull();
+  expect(verdict.verdict).toBe('uncommitted_changes');
+  expect(verdict.downgradeTo).toBe('needs_review');
+  expect(verdict.reason).toMatch(/finish protocol incomplete/);
+});
+
+test('commitGuardVerdict: no newly-dirty files → no flag regardless of other flags', () => {
+  const verdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    verifyResult: null,
+  });
+  expect(verdict).toBeNull();
+});
+
+test('commitGuardVerdict: sibling running skip still works (regression check)', () => {
+  const verdict = commitGuardVerdict({
+    newlyDirty: ['some/file.md'],
+    siblingRunning: true,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    verifyResult: null,
+  });
+  expect(verdict).toBeNull();
+});
+
+test('commitGuardVerdict: self-commit skip still works (regression check)', () => {
+  const verdict = commitGuardVerdict({
+    newlyDirty: ['some/file.md'],
+    siblingRunning: false,
+    jobSelfCommitted: true,
+    legitimateNoOp: false,
+    verifyResult: null,
+  });
+  expect(verdict).toBeNull();
+});
+
+test('commitGuardVerdict: carries forward a non-clean prior verdict as an annotation', () => {
+  const verifyResult = {
+    verdict: 'transcript_errors',
+    reason: 'grep hit an Error string',
+    downgradeTo: 'needs_review',
+  };
+  const verdict = commitGuardVerdict({
+    newlyDirty: ['some/file.md'],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    verifyResult,
+  });
+  expect(verdict).not.toBeNull();
+  expect(verdict.annotations).toEqual([{ verdict: 'transcript_errors', reason: 'grep hit an Error string' }]);
+});

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

@@ -1,17 +1,19 @@
 /**
- * scheduler-committed-in-window.test.cjs — unit tests for committedInWindow.
+ * scheduler-committed-in-window.test.cjs — unit tests for committedInWindow
+ * and computeCommittedDuringRun's bounded retry.
  *
  * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-committed-in-window.test.cjs
  */
 
 'use strict';
 
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { committedInWindow } = require('../scheduler.cjs');
+const scheduler = require('../scheduler.cjs');
+const { committedInWindow, computeCommittedDuringRun } = scheduler;
 
 function git(cwd, args) {
   return execFileSync('git', args, { cwd, encoding: 'utf8' }).trim();
@@ -125,3 +127,56 @@ test('committedInWindow sees a commit pushed from an isolated checkout, only rea
     fs.rmSync(worktreeDir, { recursive: true, force: true });
   }
 });
+
+// Reproduces the pass-no-commit-worktree / RCA 770-pr269 incidents: the live
+// commit-guard's committedInWindow() call can race against ref/object
+// visibility at the exact moment of process exit and return false even
+// though the commit is real. computeCommittedDuringRun() should retry once
+// after a bounded delay before giving up.
+test('computeCommittedDuringRun retries committedInWindow once and returns true when the retry succeeds', async () => {
+  vi.useFakeTimers();
+  try {
+    const spy = vi.spyOn(scheduler, 'committedInWindow')
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+
+    const resultPromise = computeCommittedDuringRun('/tmp/fake', 'abc', 'abc', 'start', 'until');
+    await vi.runAllTimersAsync();
+    const result = await resultPromise;
+
+    expect(result).toBe(true);
+    expect(spy).toHaveBeenCalledTimes(2);
+  } finally {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  }
+});
+
+test('computeCommittedDuringRun returns false when both committedInWindow calls return false', async () => {
+  vi.useFakeTimers();
+  try {
+    const spy = vi.spyOn(scheduler, 'committedInWindow').mockResolvedValue(false);
+
+    const resultPromise = computeCommittedDuringRun('/tmp/fake', 'abc', 'abc', 'start', 'until');
+    await vi.runAllTimersAsync();
+    const result = await resultPromise;
+
+    expect(result).toBe(false);
+    expect(spy).toHaveBeenCalledTimes(2);
+  } finally {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  }
+});
+
+test('computeCommittedDuringRun skips the retry (and the delay) when the HEAD-diff fast path already resolves true', async () => {
+  const spy = vi.spyOn(scheduler, 'committedInWindow');
+  try {
+    const result = await computeCommittedDuringRun('/tmp/fake', 'headBefore', 'headAfter', 'start', 'until');
+
+    expect(result).toBe(true);
+    expect(spy).not.toHaveBeenCalled();
+  } finally {
+    vi.restoreAllMocks();
+  }
+});

package/src/main/__tests__/scheduler-find-prd-dir.test.cjs

@@ -0,0 +1,42 @@
+/**
+ * scheduler-find-prd-dir.test.cjs — unit test for findPrdDir's legacy-dir
+ * fallback (PRD 812 split-brain fix): a PRD slug that exists only in the
+ * legacy global `~/.claude/session-manager/scheduled-plans/prds/` dir (not
+ * yet migrated into any project's own
+ * `<cwd>/session-manager-operations/scheduler/prds/`) must still resolve,
+ * since findPrdDir's candidatePrdsDirs() searches the legacy dir first.
+ *
+ * Touches the real legacy PRDS_DIR (scheduler.cjs hard-codes it from
+ * os.homedir(), same as other scheduler unit tests that exercise
+ * global-path-backed exports) with a unique slug, and cleans up after itself.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-find-prd-dir.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { findPrdDir, PRDS_DIR } = require('../scheduler.cjs');
+
+test('findPrdDir resolves a slug that exists only in the legacy global PRDs dir', async () => {
+  const slug = `812-test-legacy-only-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const legacyPath = path.join(PRDS_DIR, `${slug}.md`);
+  fs.mkdirSync(PRDS_DIR, { recursive: true });
+  fs.writeFileSync(legacyPath, '---\ntitle: legacy fixture\n---\n\n# Goal\n\ntest\n', 'utf8');
+
+  try {
+    const dir = await findPrdDir(slug);
+    expect(dir).toBe(PRDS_DIR);
+  } finally {
+    fs.rmSync(legacyPath, { force: true });
+  }
+});
+
+test('findPrdDir returns null for a slug that exists nowhere', async () => {
+  const slug = `812-test-nonexistent-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const dir = await findPrdDir(slug);
+  expect(dir).toBe(null);
+});

package/src/main/__tests__/scheduler-investigation-clean-skip.test.cjs

@@ -0,0 +1,63 @@
+/**
+ * scheduler-investigation-clean-skip.test.cjs — a run that verified clean
+ * (exit 0 + a completed-equivalent verdict) has nothing left to diagnose;
+ * spawnInvestigation must decline rather than manufacturing a depth+1
+ * fix-of-a-fix PRD for already-shipped work (PRD
+ * 812-689-fix-fix-distribute-adminserver-routes).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-investigation-clean-skip.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { shouldSkipInvestigationForCleanRun } = require('../scheduler.cjs');
+
+test('declines for a clean, exit-0 run', () => {
+  expect(shouldSkipInvestigationForCleanRun({
+    meta: { exitCode: 0 },
+    verdicts: { verdict: 'clean' },
+  })).toBe(true);
+});
+
+test('declines for pass_no_commit_already_shipped, exit-0', () => {
+  expect(shouldSkipInvestigationForCleanRun({
+    meta: { exitCode: 0 },
+    verdicts: { verdict: 'pass_no_commit_already_shipped' },
+  })).toBe(true);
+});
+
+test('declines for pass_no_commit_target_verified, exit-0', () => {
+  expect(shouldSkipInvestigationForCleanRun({
+    meta: { exitCode: 0 },
+    verdicts: { verdict: 'pass_no_commit_target_verified' },
+  })).toBe(true);
+});
+
+test('proceeds (does not skip) for exitCode 1', () => {
+  expect(shouldSkipInvestigationForCleanRun({
+    meta: { exitCode: 1 },
+    verdicts: { verdict: 'clean' },
+  })).toBe(false);
+});
+
+test('proceeds for exit 0 with a non-completed-equivalent verdict', () => {
+  expect(shouldSkipInvestigationForCleanRun({
+    meta: { exitCode: 0 },
+    verdicts: { verdict: 'transcript_errors' },
+  })).toBe(false);
+});
+
+test('proceeds (fail-open) when verdicts.json is missing', () => {
+  expect(shouldSkipInvestigationForCleanRun({
+    meta: { exitCode: 0 },
+    verdicts: null,
+  })).toBe(false);
+});
+
+test('proceeds (fail-open) when meta.json is missing', () => {
+  expect(shouldSkipInvestigationForCleanRun({
+    meta: null,
+    verdicts: { verdict: 'clean' },
+  })).toBe(false);
+});

package/src/main/__tests__/scheduler-meta-code-sha.test.cjs

@@ -0,0 +1,23 @@
+/**
+ * scheduler-meta-code-sha.test.cjs — unit tests for the SCHEDULER_BOOTED_AT /
+ * SCHEDULER_CODE_SHA constants stamped into every run's meta sidecar (PRD
+ * 812-fix-commit-guard-retry-on-worktree-ref-visibility-delay): a stale
+ * scheduler process is otherwise invisible in the run record, which cost a
+ * full investigation to diagnose a false pass_no_commit.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-meta-code-sha.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { SCHEDULER_BOOTED_AT, SCHEDULER_CODE_SHA } = require('../scheduler.cjs');
+
+test('SCHEDULER_BOOTED_AT is a valid ISO date string', () => {
+  expect(typeof SCHEDULER_BOOTED_AT).toBe('string');
+  expect(Number.isNaN(new Date(SCHEDULER_BOOTED_AT).getTime())).toBe(false);
+});
+
+test('SCHEDULER_CODE_SHA is null or a short git hex SHA', () => {
+  expect(SCHEDULER_CODE_SHA === null || /^[0-9a-f]{7,40}$/.test(SCHEDULER_CODE_SHA)).toBe(true);
+});

package/src/main/__tests__/scheduler-notify-originating-tab.test.cjs

@@ -97,3 +97,71 @@ test('no-ops when parsing the PRD frontmatter throws', async () => {
 
   expect(sendPrompt).not.toHaveBeenCalled();
 });
+
+// PRD 814: a dev-work ticket's completion notification routes into its own
+// PromptSession's event chain instead of an unrelated tab, when the PRD's
+// sourcePromptId resolves to a known, still-active PromptSession.
+test('routes into the known PromptSession event chain and never falls back to a tab prompt', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1', sourceTabId: 'tab-x' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledWith(
+    '/some/cwd',
+    'psess-1',
+    expect.stringContaining('814-notify'),
+  );
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('falls back to the tab-external-ticket path when sourcePromptId does not resolve to a known PromptSession', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => false);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-unknown', sourceTabId: 'tab-x' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalled();
+  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
+});
+
+test('falls back to the tab-external-ticket path when the PRD has no sourcePromptId at all (pre-813 PRD)', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: null, sourceTabId: 'tab-x' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
+  );
+
+  expect(appendResponseEvent).not.toHaveBeenCalled();
+  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
+});
+
+test('falls back to the tab-external-ticket path when appendResponseEvent itself throws', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => { throw new Error('disk error'); });
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1', sourceTabId: 'tab-x' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await expect(
+    notifyOriginatingTab(
+      { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
+      { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
+    ),
+  ).resolves.not.toThrow();
+
+  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
+});

package/src/main/__tests__/scheduler-reset-job-fields-guard.test.cjs

@@ -0,0 +1,77 @@
+/**
+ * scheduler-reset-job-fields-guard.test.cjs — unit tests for resetJobFields'
+ * terminal-status guard.
+ *
+ * A 'completed' job already landed its deliverable — resetting it back to
+ * 'pending' re-fires the PRD and re-executes already-shipped work (the
+ * incident: PRD 812-workbench-review-nits-cleanup was reset and re-run this
+ * way, burning a full claude -p job + Opus investigation over a correct
+ * no-op). resetJobFields must refuse (no-op) on a 'completed' job unless
+ * opts.force is true, and must still reset normally for every non-terminal
+ * status (pending/running/failed/needs_review).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reset-job-fields-guard.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { resetJobFields } = require('../scheduler.cjs');
+
+function makeJob(status, overrides = {}) {
+  return {
+    slug: 'test-slug',
+    status,
+    runId: 'run-123',
+    startedAt: '2026-07-31T00:00:00.000Z',
+    finishedAt: '2026-07-31T00:05:00.000Z',
+    exitCode: 0,
+    error: null,
+    runtime: { pid: 999 },
+    verifierVerdict: 'pass',
+    landedCommit: 'abc1234',
+    ...overrides,
+  };
+}
+
+test('resetJobFields: refuses and does not mutate a completed job', () => {
+  const job = makeJob('completed');
+  const snapshot = { ...job };
+  const result = resetJobFields(job, 'some error');
+  expect(result).toBe(false);
+  expect(job).toEqual(snapshot);
+});
+
+test('resetJobFields: force:true overrides the guard on a completed job', () => {
+  const job = makeJob('completed');
+  const result = resetJobFields(job, 'forced reset', { force: true });
+  expect(result).toBe(true);
+  expect(job.status).toBe('pending');
+  expect(job.runId).toBeNull();
+  expect(job.startedAt).toBeNull();
+  expect(job.finishedAt).toBeNull();
+  expect(job.exitCode).toBeNull();
+  expect(job.error).toBe('forced reset');
+  expect(job.runtime).toBeUndefined();
+  expect(job.verifierVerdict).toBeUndefined();
+  // landedCommit must survive even a forced reset — it feeds the
+  // pass_no_commit_prior_run_verified exemption on a later re-run.
+  expect(job.landedCommit).toBe('abc1234');
+});
+
+for (const status of ['pending', 'running', 'failed', 'needs_review']) {
+  test(`resetJobFields: resets normally for non-terminal status '${status}'`, () => {
+    const job = makeJob(status);
+    const result = resetJobFields(job, 'retry reason');
+    expect(result).toBe(true);
+    expect(job.status).toBe('pending');
+    expect(job.runId).toBeNull();
+    expect(job.startedAt).toBeNull();
+    expect(job.finishedAt).toBeNull();
+    expect(job.exitCode).toBeNull();
+    expect(job.error).toBe('retry reason');
+    expect(job.runtime).toBeUndefined();
+    expect(job.verifierVerdict).toBeUndefined();
+    expect(job.landedCommit).toBe('abc1234');
+  });
+}

package/src/main/__tests__/scheduler-unreadable-queue-guard.test.cjs

@@ -0,0 +1,62 @@
+/**
+ * scheduler-unreadable-queue-guard.test.cjs — regression cover for the
+ * 2026-07-31 mass-resurrection incident.
+ *
+ * readQueue()/readQueueSync() used to swallow EVERY error and return
+ * `jobs: []`. A single unreadable or half-written queue.json therefore looked
+ * identical to an empty queue, so reconcile() saw no job row for any PRD .md
+ * on disk, re-minted all of them as fresh 'pending', and mutate() persisted
+ * that empty-derived state over the real file — 189 completed jobs resurrected
+ * and fired into an ENOENT retry storm.
+ *
+ * The fix marks such a read `unreadable` (a MISSING file stays a legitimately
+ * empty queue) and refuses to let that state reach the two functions that
+ * would do the damage. Both guards below return/throw before touching the
+ * filesystem, so this test can never disturb the real queue.json.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-unreadable-queue-guard.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { writeQueue, reconcile, forceTickOutcome } = require('../scheduler.cjs');
+
+const unreadableState = () => ({
+  config: {},
+  jobs: [],
+  scheduledFor: null,
+  lastRunAt: null,
+  paused: null,
+  unreadable: 'Unexpected token } in JSON at position 42',
+});
+
+test('writeQueue refuses to persist a state derived from an unreadable read', async () => {
+  await expect(writeQueue(unreadableState())).rejects.toThrow(/refusing to write queue\.json/i);
+});
+
+test('writeQueue still persists a normal state (guard is not a blanket block)', () => {
+  // Only assert the guard does not fire — the real write is exercised by the
+  // scheduler's own integration paths, and this test must not touch the file.
+  const state = { config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
+  expect(state.unreadable).toBeUndefined();
+});
+
+test('reconcile refuses an unreadable state instead of resurrecting every PRD', async () => {
+  await expect(reconcile(unreadableState())).rejects.toThrow(/reconcile skipped/i);
+});
+
+test('forceTickOutcome surfaces an unreadable queue as a hard error, not "No pending jobs"', () => {
+  const out = forceTickOutcome({ fired: false, reason: 'unreadable' });
+  expect(out.ok).toBe(false);
+  expect(out.kind).toBe('error');
+  expect(out.message).toMatch(/unreadable/i);
+});
+
+test('an absent queue.json is still a legitimately empty queue, not an error', () => {
+  // ENOENT keeps the old fail-open behaviour on purpose: first boot has no
+  // file yet and must be allowed to create one.
+  const out = forceTickOutcome({ fired: false, reason: 'drained' });
+  expect(out.ok).toBe(true);
+  expect(out.message).toMatch(/No pending jobs/i);
+});

package/src/main/browserView.cjs

@@ -223,13 +223,14 @@ function create({ viewId, partition }) {
     },
   });
   views.set(viewId, view);
-  browserViewContentsIds.add(view.webContents.id);
-  contentsIdToViewId.set(view.webContents.id, viewId);
+  const wcId = view.webContents.id;
+  browserViewContentsIds.add(wcId);
+  contentsIdToViewId.set(wcId, viewId);
   view.webContents.setZoomFactor(lastZoomFactor);
   wireNavEvents(viewId, view);
   view.webContents.once('destroyed', () => {
-    browserViewContentsIds.delete(view.webContents.id);
-    contentsIdToViewId.delete(view.webContents.id);
+    browserViewContentsIds.delete(wcId);
+    contentsIdToViewId.delete(wcId);
     recordingViewIds.delete(viewId);
     stepCounters.delete(viewId);
     recordTokens.delete(viewId);