@productbrain/cli 0.1.0-beta.984 → 0.1.0-beta.9860

package/dist/__tests__/handshake.test.js

@@ -1,9 +1,7 @@
 /**
  * pb handshake --init — unit tests.
  * DEC-271: two-file split (team vs personal). DEC-272: permission whitelist.
- * TEN-712: hooks must fail silently (|| true suffix).
- *
- * WP-379 S3b: probeStarterSetupSeeded + pollUntilSeedsReady tests.
+ * TEN-712: every hook command must end with '|| true' so it never blocks Claude Code from starting.
  */
 import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
 import { join } from 'path';
@@ -11,10 +9,23 @@ import { join } from 'path';
 // vi.mock('fs', ...) below hoists this mock, so these imports resolve to the mocked versions.
 import { readdirSync as readdirSyncMock } from 'fs';
 // vi.mock calls are hoisted — use vi.hoisted() for constants referenced inside factories.
-const { vfs, vfsMtimes, MOCK_CWD, MOCK_HOME } = vi.hoisted(() => ({
+const { vfs, vfsMtimes, vfsDirs, vfsSymlinks, vfsRealpaths, vfsInodes, MOCK_CWD, MOCK_HOME } = vi.hoisted(() => ({
     vfs: {},
     // WP-379 S5b: mtime map used by statSync mock for case-collision ordering tests.
     vfsMtimes: {},
+    // PR #912 follow-up: lstatSync needs dir-vs-file-vs-symlink distinction, which the flat
+    // `vfs` content map doesn't carry (a directory marker is stored as `vfs[dir] = ''`, same
+    // shape as an empty file) — these two sets disambiguate for the Cursor nested-skills tests.
+    vfsDirs: new Set(),
+    vfsSymlinks: new Set(),
+    // PR #912 follow-up (Cursor security review): explicit path→realpath overrides so a test can
+    // simulate an INTERMEDIATE symlinked component (e.g. .cursor/skills itself) resolving outside
+    // the repo, distinct from vfsSymlinks which only marks the final path component as a link.
+    vfsRealpaths: new Map(),
+    // Round 13: explicit path→ino override so a test can make two case-variant paths resolve to
+    // the SAME filesystem entry (case-insensitive FS simulation). Unset paths fall back to a
+    // deterministic per-path hash in the statSync mock below.
+    vfsInodes: new Map(),
     MOCK_CWD: '/tmp/pb-test-cwd',
     MOCK_HOME: '/tmp/pb-test-home',
 }));
@@ -43,10 +54,51 @@ vi.mock('fs', () => ({
             // Return a fake stat with an incrementing mtime based on path hash (deterministic).
             // Tests that need specific mtime ordering should set vfs[path] before calling.
             const mtimeMs = vfsMtimes[path] ?? 1000;
-            return { mtimeMs };
+            // Round 13: dev/ino for case-insensitive-alias detection. dev is constant (single fake
+            // filesystem); ino defaults to a deterministic per-path hash unless a test overrides it
+            // via vfsInodes to make two case-variant paths resolve to the same entry.
+            let ino = vfsInodes.get(path);
+            if (ino === undefined) {
+                let h = 0;
+                for (let i = 0; i < path.length; i++)
+                    h = (h * 31 + path.charCodeAt(i)) | 0;
+                ino = h;
+            }
+            return { mtimeMs, dev: 1, ino };
         }
         throw Object.assign(new Error(`ENOENT: stat '${path}'`), { code: 'ENOENT' });
     }),
+    // PR #912 follow-up: lstatSync backs the Cursor nested-skills symlink refusal — never
+    // follows a link, so a path marked in vfsSymlinks reports neither isDirectory() nor isFile().
+    lstatSync: vi.fn((path) => {
+        const isSymlink = vfsSymlinks.has(path);
+        const isDir = vfsDirs.has(path);
+        const isFile = !isSymlink && !isDir && path in vfs;
+        if (!isSymlink && !isDir && !isFile) {
+            throw Object.assign(new Error(`ENOENT: lstat '${path}'`), { code: 'ENOENT' });
+        }
+        // Round 15: dev/ino for directory-entry-identity comparisons (findLeftoverCursorSkills'
+        // live-alias check). Same default-hash-or-vfsInodes-override scheme as statSync below.
+        let ino = vfsInodes.get(path);
+        if (ino === undefined) {
+            let h = 0;
+            for (let i = 0; i < path.length; i++)
+                h = (h * 31 + path.charCodeAt(i)) | 0;
+            ino = h;
+        }
+        return {
+            isDirectory: () => isDir,
+            isFile: () => isFile,
+            isSymbolicLink: () => isSymlink,
+            dev: 1,
+            ino,
+        };
+    }),
+    // PR #912 follow-up: realpathSync backs the Cursor-skills-root containment check — an explicit
+    // vfsRealpaths override simulates an intermediate symlinked component; otherwise identity.
+    // Identity by default (a real fs resolves an ordinary path, including MOCK_CWD itself, to
+    // itself) — vfsRealpaths overrides model a specific symlinked path resolving elsewhere.
+    realpathSync: vi.fn((path) => vfsRealpaths.get(path) ?? path),
 }));
 vi.mock('os', () => ({
     homedir: vi.fn(() => MOCK_HOME),
@@ -59,8 +111,11 @@ vi.mock('../lib/prompts.js', () => ({
     password: () => Promise.resolve(''),
     isInteractive: () => true,
 }));
-import { runHandshakeInit, normalizeHandshakeContentForComparison, DORMANT_MARKER, writeDormantMarkerToFile, resolveProjectionCollision, classifyDriftBucket } from '../commands/handshake.js';
+import { runHandshakeInit, normalizeHandshakeContentForComparison, findLeftoverProjections, classifyDriftBucket, deriveHandshakeStartupSignals, dereferencePrRefToPaths } from '../commands/handshake.js';
+import { findLeftoverCursorSkills, LEFTOVER_FILES_MAX } from '../commands/handshakeCursorSkillCleanup.js';
 import { MARKER } from '../generators/adapters.js';
+/** PR #911 review (Codex P2): findLeftoverProjections scopes reporting to allowedTargets — tests that want every surface scanned pass this. */
+const ALL_SURFACES = new Set(['cursor', 'claude', 'codex', 'copilot']);
 import { createHash } from 'crypto';
 const TEAM_PATH = join(MOCK_CWD, '.claude', 'settings.json');
 const PERSONAL_PATH = join(MOCK_HOME, '.claude', 'settings.json');
@@ -176,7 +231,7 @@ describe('runHandshakeInit', () => {
             await runHandshakeInit({ level: 'work', dryRun: false });
             const team = JSON.parse(vfs[TEAM_PATH]);
             const cmd = team.hooks.SessionStart[0].hooks[0].command;
-            expect(cmd).toBe('pb session start 2>/dev/null || true');
+            expect(cmd).toBe("pb session start 2>&1 || true");
         });
         it('pb session close hook command is exact', async () => {
             await runHandshakeInit({ level: 'work', dryRun: false });
@@ -220,337 +275,321 @@ describe('normalizeHandshakeContentForComparison', () => {
         expect(normalizeHandshakeContentForComparison(a)).not.toBe(normalizeHandshakeContentForComparison(b));
     });
 });
-// ── WP-379 S3b: probeStarterSetupSeeded + pollUntilSeedsReady ─────────────────
-//
-// These tests use vi.doMock (not vi.mock) so they can inject different
-// kernelCall implementations per test without affecting the --init tests above.
-// Each test creates its own isolated module scope via vi.resetModules().
-describe('probeStarterSetupSeeded (WP-379 S3b)', () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('returns seeds-ready when health.starterSetupSeeded is true', async () => {
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockResolvedValue({
-                starterSetupSeeded: true,
-                gaps: [],
-                status: 'healthy',
-            }),
-        }));
-        const { probeStarterSetupSeeded } = await import('../commands/handshake.js');
-        const result = await probeStarterSetupSeeded();
-        expect(result.status).toBe('seeds-ready');
-    });
-    it('returns seeds-pending with starter-setup-missing gap when starterSetupSeeded is false', async () => {
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockResolvedValue({
-                starterSetupSeeded: false,
-                gaps: [
-                    {
-                        kind: 'starter-setup-missing',
-                        severity: 'error',
-                        message: 'Starter setup seeds are still running.',
-                    },
-                ],
-                status: 'incomplete',
-            }),
-        }));
-        const { probeStarterSetupSeeded } = await import('../commands/handshake.js');
-        const result = await probeStarterSetupSeeded();
-        expect(result.status).toBe('seeds-pending');
-        if (result.status === 'seeds-pending') {
-            expect(result.gaps.length).toBeGreaterThan(0);
-            expect(result.gaps[0]?.kind).toBe('starter-setup-missing');
-        }
-    });
-    it('returns probe-failed when kernelCall throws', async () => {
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockRejectedValue(new Error('Network unreachable')),
-        }));
-        const { probeStarterSetupSeeded } = await import('../commands/handshake.js');
-        const result = await probeStarterSetupSeeded();
-        expect(result.status).toBe('probe-failed');
-        if (result.status === 'probe-failed') {
-            expect(result.error).toContain('Network unreachable');
-        }
-    });
-    it('synthesizes a default starter-setup-missing gap when health.gaps is empty but starterSetupSeeded is false', async () => {
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockResolvedValue({
-                starterSetupSeeded: false,
-                gaps: [], // no gap details from server
-                status: 'incomplete',
-            }),
-        }));
-        const { probeStarterSetupSeeded } = await import('../commands/handshake.js');
-        const result = await probeStarterSetupSeeded();
-        expect(result.status).toBe('seeds-pending');
-        if (result.status === 'seeds-pending') {
-            expect(result.gaps.length).toBe(1);
-            expect(result.gaps[0]?.kind).toBe('starter-setup-missing');
-        }
-    });
-});
-describe('pollUntilSeedsReady (WP-379 S3b)', () => {
-    beforeEach(() => {
-        vi.resetModules();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-        vi.useRealTimers();
-    });
-    it('returns seeds-ready immediately when first probe succeeds', async () => {
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockResolvedValue({
-                starterSetupSeeded: true,
-                gaps: [],
-                status: 'healthy',
-            }),
-        }));
-        const { pollUntilSeedsReady } = await import('../commands/handshake.js');
-        const resultPromise = pollUntilSeedsReady();
-        // Advance timers past any initial delays
-        await vi.runAllTimersAsync();
-        const result = await resultPromise;
-        expect(result.status).toBe('seeds-ready');
-    });
-    it('returns seeds-pending after MAX_POLLS when seeds never become ready', async () => {
-        // kernelCall always returns starterSetupSeeded: false
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockResolvedValue({
-                starterSetupSeeded: false,
-                gaps: [
-                    {
-                        kind: 'starter-setup-missing',
-                        severity: 'error',
-                        message: 'Starter setup seeds are still running.',
-                    },
-                ],
-                status: 'incomplete',
-            }),
-        }));
-        const { pollUntilSeedsReady } = await import('../commands/handshake.js');
-        const resultPromise = pollUntilSeedsReady();
-        await vi.runAllTimersAsync();
-        const result = await resultPromise;
-        expect(result.status).toBe('seeds-pending');
-        if (result.status === 'seeds-pending') {
-            expect(result.gaps[0]?.kind).toBe('starter-setup-missing');
-        }
-    });
-    it('stops polling immediately on probe-failed (no retry on network error)', async () => {
-        const kernelCallMock = vi.fn().mockRejectedValue(new Error('auth failed'));
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: kernelCallMock,
-        }));
-        const { pollUntilSeedsReady } = await import('../commands/handshake.js');
-        const resultPromise = pollUntilSeedsReady();
-        await vi.runAllTimersAsync();
-        const result = await resultPromise;
-        expect(result.status).toBe('probe-failed');
-        // Should have called exactly once — no retry on failure
-        expect(kernelCallMock).toHaveBeenCalledTimes(1);
-    });
-});
-// ── WP-379 S4: DORMANT_MARKER constant + writeDormantMarkerToFile ─────────────
-describe('DORMANT_MARKER (WP-379 S4)', () => {
-    it('is the expected HTML comment string', () => {
-        expect(DORMANT_MARKER).toBe('<!-- pb-status: dormant -->');
-    });
-    it('does not contain newlines (clean single-line marker)', () => {
-        expect(DORMANT_MARKER).not.toContain('\n');
-    });
-});
-describe('writeDormantMarkerToFile (WP-379 S4)', () => {
-    // Use the hoisted vfs + mocked fs from the top of this file.
-    // vfs is already set up by vi.hoisted() and vi.mock('fs', ...) above.
-    beforeEach(() => {
-        Object.keys(vfs).forEach((k) => delete vfs[k]);
-        vi.clearAllMocks();
-    });
-    const AUTO_GEN_FILE = join(MOCK_CWD, '.claude', 'rules', 'test-rule.md');
-    it('returns "skipped" when the file does not exist', () => {
-        // File is not in vfs
-        const result = writeDormantMarkerToFile(AUTO_GEN_FILE);
-        expect(result).toBe('skipped');
-    });
-    it('returns "skipped" when the file exists but has no auto-gen MARKER', () => {
-        vfs[AUTO_GEN_FILE] = '# Manual rule\nSome content.\n';
-        const result = writeDormantMarkerToFile(AUTO_GEN_FILE);
-        expect(result).toBe('skipped');
-        // File must be unchanged (no append)
-        expect(vfs[AUTO_GEN_FILE]).toBe('# Manual rule\nSome content.\n');
-    });
-    it('appends DORMANT_MARKER and returns "written" for an auto-gen file without the marker', () => {
-        // Simulate a previously-projected file: has the auto-gen MARKER, no dormant marker yet.
-        vfs[AUTO_GEN_FILE] = `${MARKER}\n# Test Rule\nContent.\n`;
-        const result = writeDormantMarkerToFile(AUTO_GEN_FILE);
-        expect(result).toBe('written');
-        expect(vfs[AUTO_GEN_FILE]).toContain(DORMANT_MARKER);
-        // Original content preserved — marker is appended, not a replacement.
-        expect(vfs[AUTO_GEN_FILE]).toContain('# Test Rule');
-        expect(vfs[AUTO_GEN_FILE]).toContain(MARKER);
-    });
-    it('returns "already-dormant" when DORMANT_MARKER is already present (idempotent)', () => {
-        // File already has the dormant marker from a previous handshake.
-        vfs[AUTO_GEN_FILE] = `${MARKER}\n# Test Rule\nContent.\n\n${DORMANT_MARKER}\n`;
-        const result = writeDormantMarkerToFile(AUTO_GEN_FILE);
-        expect(result).toBe('already-dormant');
-        // File must be unchanged — no second append.
-        const occurrences = (vfs[AUTO_GEN_FILE].match(new RegExp(DORMANT_MARKER.replace(/[<>!-]/g, '\\$&'), 'g')) ?? []).length;
-        expect(occurrences).toBe(1);
-    });
-    it('second call on a dormant-marked file produces no duplicate markers (no drift TEN semantics)', () => {
-        // Simulate: first handshake wrote the dormant marker, second handshake is called again.
-        vfs[AUTO_GEN_FILE] = `${MARKER}\n# Test Rule\n\n${DORMANT_MARKER}\n`;
-        writeDormantMarkerToFile(AUTO_GEN_FILE); // first call — already-dormant
-        writeDormantMarkerToFile(AUTO_GEN_FILE); // second call — still already-dormant
-        const occurrences = (vfs[AUTO_GEN_FILE].match(new RegExp(DORMANT_MARKER.replace(/[<>!-]/g, '\\$&'), 'g')) ?? []).length;
-        expect(occurrences).toBe(1);
-    });
-});
-// ── WP-379 S5b: resolveProjectionCollision ─────────────────────────────────────
+// WP-379 S3b's probeStarterSetupSeeded + pollUntilSeedsReady tests deleted at WP-776 S0
+// round-1 review (Codex P1, verified regression): nothing seeds setup-assets any more, so
+// the functions they tested (whose readiness gate was keyed on starterSetupSeeded alone)
+// are deleted from packages/cli/src/commands/handshake.ts.
+// ── WP-379 S5b: findLeftoverProjections + findLeftoverCursorSkills — REPORT-ONLY ────────────
 //
-// Tests for the marker-scoped orphan unlink + case-collision resolution.
-// All file system operations go through the vfs mock defined at the top of this file.
-describe('resolveProjectionCollision (WP-379 S5b)', () => {
-    const noop = () => { };
+// Coordinator ruling (PR #912 round 10): nine review rounds on the same unlink mechanism —
+// symlinks, case collisions, empty-DB states, tamper preservation — is the signal that a
+// deletion mechanism over a user's filesystem is defensive machinery whose edge cases never
+// end. pb handshake no longer unlinks, renames, or recreates any leftover file; these tests
+// assert survival AND report inclusion for each stale class. All file system operations go
+// through the vfs mock defined at the top of this file.
+describe('findLeftoverProjections (WP-379 S5b, report-only)', () => {
     beforeEach(() => {
-        // Clear vfs and mtimes before each test.
         Object.keys(vfs).forEach((k) => delete vfs[k]);
         Object.keys(vfsMtimes).forEach((k) => delete vfsMtimes[k]);
+        vfsDirs.clear();
+        vfsSymlinks.clear();
+        vfsRealpaths.clear();
+        vfsInodes.clear();
         vi.clearAllMocks();
     });
-    // Helper: write a file to vfs with the auto-gen MARKER.
-    // Also marks the parent directory as existing in vfs so existsSync(dir) returns true.
     function writeMarkedFile(path, extra = '') {
         const dir = path.substring(0, path.lastIndexOf('/'));
-        vfs[dir] = ''; // ensure existsSync(dir) returns true
+        vfs[dir] = '';
         vfs[path] = `${MARKER}\n# Rule\n${extra}`;
     }
-    // Helper: write a file without auto-gen MARKER (user-forked).
-    // Also marks the parent directory as existing in vfs so existsSync(dir) returns true.
     function writeUserFile(path) {
         const dir = path.substring(0, path.lastIndexOf('/'));
-        vfs[dir] = ''; // ensure existsSync(dir) returns true
+        vfs[dir] = '';
         vfs[path] = '# My user rule — no marker here\n';
     }
-    // ── Test 1: Linux case-collision — exact match wins ────────────────────────
-    it('case-collision: exact-match file survives, case-variant with marker is unlinked', () => {
+    it('an exact-match file is not reported; a case-variant with the same stem is reported as leftover and survives', () => {
         const dir = `${MOCK_CWD}/.cursor/rules`;
-        const exact = `${dir}/setup-productbrain.mdc`; // lowercase = normalized stem
-        const variant = `${dir}/Setup-ProductBrain.mdc`; // case-variant
-        // Both have the auto-gen MARKER.
+        const exact = `${dir}/setup-productbrain.mdc`;
+        const variant = `${dir}/Setup-ProductBrain.mdc`;
         writeMarkedFile(exact);
         writeMarkedFile(variant);
-        // Simulate readdirSync returning both files for the .cursor/rules dir.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        readdirSyncMock.mockImplementation((d) => {
-            if (d === dir)
-                return ['setup-productbrain.mdc', 'Setup-ProductBrain.mdc'];
-            return [];
-        });
-        // Both are known canonical (same normalized stem).
-        const assetNames = ['setup-productbrain'];
-        const { results, collisionTens } = resolveProjectionCollision(MOCK_CWD, assetNames, noop, noop);
-        // Exact match survives.
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['setup-productbrain.mdc', 'Setup-ProductBrain.mdc'] : []));
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, ['setup-productbrain'], ALL_SURFACES);
         expect(exact in vfs).toBe(true);
-        // Case-variant is unlinked.
-        expect(variant in vfs).toBe(false);
-        // Exact match appears as 'kept'.
-        expect(results.some((r) => r.filePath === exact && r.action === 'kept')).toBe(true);
-        // Variant appears as 'unlinked'.
-        expect(results.some((r) => r.filePath === variant && r.action === 'unlinked')).toBe(true);
-        // No collision TEN — exact match was found.
-        expect(collisionTens).toHaveLength(0);
-    });
-    // ── Test 2: ambiguous case (no exact match, two case-variants) ────────────
-    it('ambiguous case: zero exact match, two case-variants → newest mtime wins + TEN captured', () => {
+        expect(variant in vfs).toBe(true); // survives — never unlinked
+        expect(leftovers.some((l) => l.path === exact)).toBe(false); // current — not reported
+        expect(leftovers.some((l) => l.path === variant && l.reason.includes('stale case'))).toBe(true);
+    });
+    it('a marker-bearing file with no canonical match is reported as an orphan and survives', () => {
         const dir = `${MOCK_CWD}/.cursor/rules`;
-        const variant1 = `${dir}/Setup-ProductBrain.mdc`; // older
-        const variant2 = `${dir}/SETUP-PRODUCTBRAIN.mdc`; // newer
-        writeMarkedFile(variant1);
-        writeMarkedFile(variant2);
-        // Set mtimes: variant2 is newer (higher ms).
-        vfsMtimes[variant1] = 1000;
-        vfsMtimes[variant2] = 9000; // newer
+        const orphan = `${dir}/old-orphaned-rule.mdc`;
+        writeMarkedFile(orphan);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        readdirSyncMock.mockImplementation((d) => {
-            if (d === dir)
-                return ['Setup-ProductBrain.mdc', 'SETUP-PRODUCTBRAIN.mdc'];
-            return [];
-        });
-        // The canonical name is lowercase "setup-productbrain" — neither variant is an exact stem match.
-        const assetNames = ['setup-productbrain'];
-        const { results, collisionTens } = resolveProjectionCollision(MOCK_CWD, assetNames, noop, noop);
-        // variant2 (newer mtime=9000) must survive; variant1 (older mtime=1000) must be unlinked.
-        expect(variant2 in vfs).toBe(true);
-        expect(variant1 in vfs).toBe(false);
-        // A collision TEN must be captured.
-        expect(collisionTens).toHaveLength(1);
-        expect(collisionTens[0]).toContain('setup-productbrain.mdc');
-        // result for winner should be 'collision-ten', loser 'unlinked'.
-        expect(results.some((r) => r.filePath === variant2 && r.action === 'collision-ten')).toBe(true);
-        expect(results.some((r) => r.filePath === variant1 && r.action === 'unlinked')).toBe(true);
-    });
-    // ── Test 3: existing user file (no marker) → never unlinked, zero drift TENs ──
-    // Note: resolveProjectionCollision does NOT fire drift TENs — user-owned files
-    // (no MARKER) are left untouched by the main write loop in runHandshake (TEN-2150).
-    // This test confirms that user-owned files are NEVER unlinked by
-    // resolveProjectionCollision regardless of name.
-    it('first-run: user file (no marker) in target dir is preserved (never unlinked)', () => {
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['old-orphaned-rule.mdc'] : []));
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, ['some-other-rule'], ALL_SURFACES);
+        expect(orphan in vfs).toBe(true); // survives — never unlinked
+        expect(leftovers.some((l) => l.path === orphan && l.reason.includes('orphan'))).toBe(true);
+    });
+    it('a leftover .dormant file is reported and survives, regardless of content match with its live sibling', () => {
+        const dir = `${MOCK_CWD}/.claude/rules`;
+        const live = `${dir}/setup-productbrain.md`;
+        const dormant = `${dir}/setup-productbrain.md.dormant`;
+        writeMarkedFile(live, 'Same body');
+        writeMarkedFile(dormant, 'Same body');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['setup-productbrain.md', 'setup-productbrain.md.dormant'] : []));
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, ['setup-productbrain'], ALL_SURFACES);
+        expect(live in vfs).toBe(true);
+        expect(dormant in vfs).toBe(true); // survives, even though content matches the live file
+        expect(leftovers.some((l) => l.path === live)).toBe(false);
+        expect(leftovers.some((l) => l.path === dormant && l.reason.includes('.dormant'))).toBe(true);
+    });
+    it('a user-owned file (no marker) is never reported and never touched', () => {
         const dir = `${MOCK_CWD}/.cursor/rules`;
         const userFile = `${dir}/foo.mdc`;
-        writeUserFile(userFile); // NO auto-gen MARKER
+        writeUserFile(userFile);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        readdirSyncMock.mockImplementation((d) => {
-            if (d === dir)
-                return ['foo.mdc'];
-            return [];
-        });
-        // 'foo' is NOT a canonical asset name — it would be an orphan if it had a marker.
-        const assetNames = [];
-        const { results } = resolveProjectionCollision(MOCK_CWD, assetNames, noop, noop);
-        // User file untouched.
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['foo.mdc'] : []));
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, [], ALL_SURFACES);
         expect(userFile in vfs).toBe(true);
-        // No unlink results.
-        expect(results.filter((r) => r.action === 'unlinked')).toHaveLength(0);
+        expect(leftovers.some((l) => l.path === userFile)).toBe(false);
     });
-    // ── Test 4: orphan auto-gen file is unlinked ──────────────────────────────
-    it('auto-gen file whose name is not in the active asset list is unlinked (orphan)', () => {
-        const dir = `${MOCK_CWD}/.cursor/rules`;
-        const orphan = `${dir}/old-orphaned-rule.mdc`;
+    it('an unselected surface is left unreported entirely', () => {
+        const dir = `${MOCK_CWD}/.codex/skills`;
+        const orphan = `${dir}/old-skill.md`;
         writeMarkedFile(orphan);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        readdirSyncMock.mockImplementation((d) => {
-            if (d === dir)
-                return ['old-orphaned-rule.mdc'];
-            return [];
-        });
-        // Active assets do NOT include "old-orphaned-rule".
-        const assetNames = ['some-other-rule'];
-        const { results } = resolveProjectionCollision(MOCK_CWD, assetNames, noop, noop);
-        expect(orphan in vfs).toBe(false);
-        expect(results.some((r) => r.filePath === orphan && r.action === 'unlinked')).toBe(true);
-    });
-    // ── Test 5: user file in target dir does NOT get a drift TEN from resolveProjectionCollision ──
-    // (Confirms that drift TEN suppression on first run is independent — tests Test 3 from another angle.)
-    it('returns zero collisionTens when all user files are preserved (no marker)', () => {
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['old-skill.md'] : []));
+        const claudeOnly = new Set(['claude']);
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, [], claudeOnly);
+        expect(orphan in vfs).toBe(true);
+        expect(leftovers.some((l) => l.path === orphan)).toBe(false);
+    });
+    it('PR #912 round 11 (Codex P2): a generated router/index file (no matching asset name) is not reported when its exact path is in the write plan', () => {
+        const dir = `${MOCK_CWD}/.codex/skills`;
+        const indexFile = `${dir}/README.md`;
+        writeMarkedFile(indexFile);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['README.md'] : []));
+        // No asset name matches "readme" — the old asset-name-only comparison would call this an
+        // orphan even though the write plan legitimately (re)generates it every run.
+        const exactRelativePaths = new Set(['.codex/skills/README.md']);
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, ['setup-productbrain'], ALL_SURFACES, undefined, exactRelativePaths);
+        expect(leftovers.some((l) => l.path === indexFile)).toBe(false);
+    });
+    it('PR #912 round 11 (Codex P2): a canonical raw name not already in normalized form is not reported as a stale variant when it is the exact write-plan path', () => {
         const dir = `${MOCK_CWD}/.claude/rules`;
-        const userFile = `${dir}/bar.md`;
-        writeUserFile(userFile);
+        const rawNameFile = `${dir}/Setup Skill.md`;
+        writeMarkedFile(rawNameFile);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        readdirSyncMock.mockImplementation((d) => {
-            if (d === dir)
-                return ['bar.md'];
-            return [];
-        });
-        const { collisionTens } = resolveProjectionCollision(MOCK_CWD, [], noop, noop);
-        expect(collisionTens).toHaveLength(0);
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['Setup Skill.md'] : []));
+        // "Setup Skill" normalizes to "setup-skill", so the raw filename's stem !== its normalized
+        // form — without the exact-path carve-out this reads as a stale case/punctuation variant
+        // even though the writer emits this exact raw name every run.
+        const exactRelativePaths = new Set(['.claude/rules/Setup Skill.md']);
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, ['Setup Skill'], ALL_SURFACES, undefined, exactRelativePaths);
+        expect(leftovers.some((l) => l.path === rawNameFile)).toBe(false);
+    });
+    it('PR #912 round 11 (Codex P2): without the exact-path carve-out, that same raw-name file is still (wrongly) reported as a stale variant — pins the failure mode the fix closes', () => {
+        const dir = `${MOCK_CWD}/.claude/rules`;
+        const rawNameFile = `${dir}/Setup Skill.md`;
+        writeMarkedFile(rawNameFile);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === dir ? ['Setup Skill.md'] : []));
+        const { files: leftovers } = findLeftoverProjections(MOCK_CWD, ['Setup Skill'], ALL_SURFACES);
+        expect(leftovers.some((l) => l.path === rawNameFile && l.reason.includes('stale case'))).toBe(true);
+    });
+    it('PR #912 round 13 (Codex P2): stops scanning after LEFTOVER_FILES_MAX + 1 matches, reporting truncated=true and a capped list', () => {
+        const dir = `${MOCK_CWD}/.cursor/rules`;
+        const count = LEFTOVER_FILES_MAX + 5;
+        const filenames = Array.from({ length: count }, (_, i) => `orphan-${i}.mdc`);
+        for (const f of filenames)
+            writeMarkedFile(`${dir}/${f}`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === dir ? filenames : []));
+        const { files: leftovers, truncated } = findLeftoverProjections(MOCK_CWD, [], ALL_SURFACES);
+        expect(truncated).toBe(true);
+        expect(leftovers).toHaveLength(LEFTOVER_FILES_MAX);
+        // Every file still survives on disk — this is I/O and reporting bound, never deletion.
+        for (const f of filenames)
+            expect(`${dir}/${f}` in vfs).toBe(true);
+    });
+    it('a count at exactly the cap is NOT reported as truncated', () => {
+        const dir = `${MOCK_CWD}/.cursor/rules`;
+        const filenames = Array.from({ length: LEFTOVER_FILES_MAX }, (_, i) => `orphan-${i}.mdc`);
+        for (const f of filenames)
+            writeMarkedFile(`${dir}/${f}`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === dir ? filenames : []));
+        const { files: leftovers, truncated } = findLeftoverProjections(MOCK_CWD, [], ALL_SURFACES);
+        expect(truncated).toBe(false);
+        expect(leftovers).toHaveLength(LEFTOVER_FILES_MAX);
+    });
+});
+describe('findLeftoverCursorSkills (WP-379 S5b nested layout, report-only)', () => {
+    beforeEach(() => {
+        Object.keys(vfs).forEach((k) => delete vfs[k]);
+        vfsDirs.clear();
+        vfsSymlinks.clear();
+        vfsRealpaths.clear();
+        vfsInodes.clear();
+        vi.clearAllMocks();
+    });
+    it('an orphan nested Cursor skill is reported as leftover and survives', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        const orphanDir = `${skillsDir}/old-skill`;
+        const orphanMd = `${orphanDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsDirs.add(orphanDir);
+        vfs[orphanMd] = `${MARKER}\n# Old skill\n`;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['old-skill'] : []));
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, []);
+        expect(orphanMd in vfs).toBe(true); // survives — never unlinked
+        expect(leftovers.some((l) => l.path === orphanMd && l.reason.includes('orphan'))).toBe(true);
+    });
+    it('a Title-Cased canonical Cursor skill directory is not reported (correctly current) — the write loop emits the raw canonical name', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        const activeDir = `${skillsDir}/Setup Skill`;
+        const activeMd = `${activeDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsDirs.add(activeDir);
+        vfs[activeMd] = `${MARKER}\n# Active\n`;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['Setup Skill'] : []));
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, ['Setup Skill']);
+        expect(activeMd in vfs).toBe(true);
+        expect(leftovers.some((l) => l.path === activeMd)).toBe(false);
+    });
+    it('a stale case/punctuation-variant Cursor skill directory is reported as leftover and survives — normalized stem alone is not the canonical name', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        const staleDir = `${skillsDir}/setup-skill`; // normalized stem, NOT the raw canonical name
+        const staleMd = `${staleDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsDirs.add(staleDir);
+        vfs[staleMd] = `${MARKER}\n# Stale cased\n`;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['setup-skill'] : []));
+        // Canonical raw name is Title-Cased ("Setup Skill"), never the lowercase-slug ("setup-skill").
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, ['Setup Skill']);
+        expect(staleMd in vfs).toBe(true); // survives — never unlinked
+        expect(leftovers.some((l) => l.path === staleMd && l.reason.includes('stale case'))).toBe(true);
+    });
+    it('a user-owned Cursor skill (no marker) is never reported and never touched', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        const userDir = `${skillsDir}/my-skill`;
+        const userMd = `${userDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsDirs.add(userDir);
+        vfs[userMd] = '# My own skill — no marker\n';
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['my-skill'] : []));
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, []);
+        expect(userMd in vfs).toBe(true);
+        expect(leftovers.some((l) => l.path === userMd)).toBe(false);
+    });
+    it('PR #912 round 15 (Codex P2): a case-only alias that resolves to the SAME directory entry as the canonical path is not reported as stale (case-insensitive filesystem)', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        // On a case-insensitive FS, the directory literally on disk is "setup-skill" but the OS
+        // also resolves "Setup Skill" to that SAME entry — simulate that by giving both DIRECTORY
+        // paths' lstat() the same dev+ino, exactly like a real case-insensitive filesystem would.
+        const aliasDir = `${skillsDir}/setup-skill`;
+        const canonicalDir = `${skillsDir}/Setup Skill`;
+        const aliasMd = `${aliasDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsDirs.add(aliasDir);
+        vfsDirs.add(canonicalDir); // same physical entry, reachable under either spelling
+        vfs[aliasMd] = `${MARKER}\n# Active (case-insensitive alias)\n`;
+        vfsInodes.set(aliasDir, 777);
+        vfsInodes.set(canonicalDir, 777); // same entry on a case-insensitive FS
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['setup-skill'] : []));
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, ['Setup Skill']);
+        expect(aliasMd in vfs).toBe(true); // survives — was never a candidate for removal anyway
+        expect(leftovers.some((l) => l.path === aliasMd)).toBe(false);
+    });
+    it('PR #912 round 15 (Codex P2): the SOLE on-disk entry being itself a symlink is still a live alias, not a leftover, when both case spellings resolve to it', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        // "setup-skill" is the ONLY directory entry, and it happens to be a symlink (e.g. to some
+        // external skill store) — but on a case-insensitive FS, "Setup Skill" resolves to that SAME
+        // entry too. Round 14's "never exempt a symlink" rule wrongly flagged this as stale; round 15
+        // compares lstat identity instead, which correctly treats "same entry" as a live alias
+        // regardless of whether that shared entry happens to be a symlink.
+        const aliasDir = `${skillsDir}/setup-skill`;
+        const canonicalDir = `${skillsDir}/Setup Skill`;
+        const aliasMd = `${aliasDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsSymlinks.add(aliasDir);
+        vfsSymlinks.add(canonicalDir); // same physical symlink, addressed by either spelling
+        vfs[aliasMd] = `${MARKER}\n# Active (sole entry is a symlink)\n`;
+        vfsInodes.set(aliasDir, 999);
+        vfsInodes.set(canonicalDir, 999); // identical lstat identity — one real entry
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['setup-skill'] : []));
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, ['Setup Skill']);
+        expect(aliasMd in vfs).toBe(true);
+        expect(leftovers.some((l) => l.path === aliasMd)).toBe(false);
+    });
+    it('PR #912 round 15 (Codex P2): a SYMLINKED case-only alias pointing AT a distinct canonical directory is still reported as stale (case-sensitive filesystem, two real entries)', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        // "setup-skill" is a SYMLINK pointing AT the canonical "Setup Skill" directory — TWO
+        // distinct, separately-readdirSync-visible entries. lstat (never follows) on each gives a
+        // DIFFERENT identity: the symlink's own inode vs. the real target directory's inode.
+        const aliasDir = `${skillsDir}/setup-skill`;
+        const canonicalDir = `${skillsDir}/Setup Skill`;
+        const aliasMd = `${aliasDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsSymlinks.add(aliasDir); // the discovered directory entry IS a symlink
+        vfsDirs.add(canonicalDir); // the canonical directory is a real, distinct entry
+        vfs[aliasMd] = `${MARKER}\n# Symlinked alias\n`;
+        // No vfsInodes override — default per-path hash means aliasDir and canonicalDir get
+        // DIFFERENT inos, matching two genuinely distinct filesystem objects.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['setup-skill'] : []));
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, ['Setup Skill']);
+        expect(aliasMd in vfs).toBe(true); // survives — report-only, never unlinked
+        expect(leftovers.some((l) => l.path === aliasMd && l.reason.includes('stale case'))).toBe(true);
+    });
+    it('PR #912 round 13 (Codex P2): a genuinely distinct stale directory (different inode) is still reported, even with the same normalized stem', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        const staleDir = `${skillsDir}/setup-skill`;
+        const staleMd = `${staleDir}/SKILL.md`;
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        vfsDirs.add(staleDir);
+        vfs[staleMd] = `${MARKER}\n# Genuinely stale\n`;
+        // The canonical "Setup Skill" directory doesn't exist in this test at all (lstatSync on it
+        // throws ENOENT, caught, treated as no match) — a real, distinct stale directory, not an alias.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? ['setup-skill'] : []));
+        const { files: leftovers } = findLeftoverCursorSkills(MOCK_CWD, ['Setup Skill']);
+        expect(staleMd in vfs).toBe(true); // survives — never unlinked
+        expect(leftovers.some((l) => l.path === staleMd && l.reason.includes('stale case'))).toBe(true);
+    });
+    it('PR #912 round 13 (Codex P2): stops scanning after maxResults + 1 matches, reporting truncated=true and a capped list', () => {
+        const skillsDir = `${MOCK_CWD}/.cursor/skills`;
+        const count = 8;
+        const dirNames = Array.from({ length: count }, (_, i) => `old-skill-${i}`);
+        vfs[skillsDir] = '';
+        vfsDirs.add(skillsDir);
+        for (const name of dirNames) {
+            const dir = `${skillsDir}/${name}`;
+            vfsDirs.add(dir);
+            vfs[`${dir}/SKILL.md`] = `${MARKER}\n# Orphan\n`;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        readdirSyncMock.mockImplementation((d) => (d === skillsDir ? dirNames : []));
+        const { files: leftovers, truncated } = findLeftoverCursorSkills(MOCK_CWD, [], 5);
+        expect(truncated).toBe(true);
+        expect(leftovers).toHaveLength(5);
     });
 });
 // ── WP-421 S3: classifyDriftBucket — three-bucket drift report (doneWhen #17) ──
@@ -802,4 +841,180 @@ describe('handshake vocab projector primitive (WP-436 S3)', () => {
         expect(tokenizedSource).toContain('{{vocab:work_package.plural}}');
     });
 });
+// ── WP-462 RCRT: deriveHandshakeStartupSignals — startup signal derivation ────
+//
+// Covers four findings:
+//   F4         — PR refs dereference to diff paths (spec: "PR refs must
+//                dereference to diff paths when available").
+//   Codex@665  — changedPaths derive from the committed branch delta (merge-base
+//                with origin/main), not just the dirty worktree.
+//   Codex@704  — empty-evidence handshake still yields an attribution envelope,
+//                not {} (so the domain-unresolved startup row stays queryable —
+//                spec "Loud Unresolved State", AC #4).
+//   Codex@677  — a context.md with >=25 IDs does not starve a distinct
+//                briefing.md ref (per-source quota + briefing-first ordering).
+//
+// The git/gh side effects are injected via HandshakeStartupSignalDeps so the
+// tests never touch a real subprocess. The mocked fs (vfs at the top of this
+// file) drives the .productbrain/context.md + briefing.md reads.
+describe('deriveHandshakeStartupSignals (WP-462 RCRT)', () => {
+    const CWD = MOCK_CWD;
+    // A deps object whose git runner returns canned output keyed by command, and
+    // whose prDiff returns canned paths keyed by PR number. Anything unspecified
+    // returns undefined / [] (the "command failed / no output" path).
+    function makeDeps(opts) {
+        return {
+            runGit: (_cwd, command) => opts.git?.[command],
+            prDiff: (_cwd, prNumber) => opts.prDiff?.[prNumber] ?? [],
+        };
+    }
+    beforeEach(() => {
+        Object.keys(vfs).forEach((k) => delete vfs[k]);
+        vi.clearAllMocks();
+    });
+    // ── F4: PR-ref dereference ──────────────────────────────────────────────────
+    it('F4: a "PR #177" ref dereferences to that PR\'s changed paths in the emitted signals', () => {
+        // Branch name carries the ref so collectLocalRefs picks up "PR #177".
+        const deps = makeDeps({
+            git: {
+                'git branch --show-current': 'review-pr-177',
+                'git rev-parse --short HEAD': 'abc1234',
+                // No merge-base, no dirty paths — the ONLY path source is the PR deref.
+            },
+            prDiff: { 177: ['convex/agentKnowledge/startupResolver.ts', 'kernel/telemetry/contextServed.ts'] },
+        });
+        // Pass the ref explicitly via reviewedArtifactRefs so the PR number is in `refs`.
+        const signals = deriveHandshakeStartupSignals(CWD, { reviewedArtifactRefs: ['PR #177'] }, deps);
+        expect(signals.changedPaths).toEqual(expect.arrayContaining([
+            'convex/agentKnowledge/startupResolver.ts',
+            'kernel/telemetry/contextServed.ts',
+        ]));
+        expect(signals.reviewedArtifactRefs).toContain('PR #177');
+    });
+    it('F4: absent/unauthed gh (prDiff returns []) is a graceful no-op — no PR paths, existing behavior intact', () => {
+        const deps = makeDeps({
+            git: {
+                'git branch --show-current': 'main',
+                'git rev-parse --short HEAD': 'deadbee',
+                'git diff --name-only HEAD': 'src/local-dirty.ts',
+            },
+            prDiff: {}, // every PR deref yields [] — gh absent
+        });
+        const signals = deriveHandshakeStartupSignals(CWD, { reviewedArtifactRefs: ['PR #999'] }, deps);
+        // The dirty-worktree path survives; no PR-derived paths leaked in.
+        expect(signals.changedPaths).toContain('src/local-dirty.ts');
+        expect(signals.changedPaths).not.toContain('PR #999');
+    });
+    it('F4: dereferencePrRefToPaths runs the gh command and splits name-only output', () => {
+        const calls = [];
+        const run = (_cwd, command, _timeout) => {
+            calls.push(command);
+            return 'a/one.ts\nb/two.ts\n';
+        };
+        const paths = dereferencePrRefToPaths(CWD, 177, run);
+        expect(paths).toEqual(['a/one.ts', 'b/two.ts']);
+        expect(calls[0]).toBe('gh pr diff 177 --name-only');
+    });
+    it('F4: dereferencePrRefToPaths returns [] for an invalid PR number (no gh call)', () => {
+        let called = false;
+        const run = () => {
+            called = true;
+            return undefined;
+        };
+        expect(dereferencePrRefToPaths(CWD, 0, run)).toEqual([]);
+        expect(called).toBe(false);
+    });
+    // ── Codex@665: committed branch delta, not just dirty worktree ──────────────
+    it('Codex@665: clean worktree but branch ahead of merge-base → changedPaths is non-empty', () => {
+        const deps = makeDeps({
+            git: {
+                'git branch --show-current': 'wp462-rcrt-activation',
+                'git rev-parse --short HEAD': 'feedface',
+                // Worktree is CLEAN — dirty diff returns nothing.
+                'git diff --name-only HEAD': undefined,
+                'git merge-base HEAD origin/main': 'base000',
+                // The committed branch delta vs the merge-base.
+                'git diff --name-only base000 HEAD': 'packages/cli/src/commands/handshake.ts\nconvex/schema.ts',
+            },
+        });
+        const signals = deriveHandshakeStartupSignals(CWD, {}, deps);
+        expect(signals.changedPaths).toEqual(expect.arrayContaining(['packages/cli/src/commands/handshake.ts', 'convex/schema.ts']));
+    });
+    it('Codex@665: dirty + committed deltas union and dedupe', () => {
+        const deps = makeDeps({
+            git: {
+                'git branch --show-current': 'b',
+                'git rev-parse --short HEAD': 'c',
+                'git diff --name-only HEAD': 'shared.ts\ndirty-only.ts',
+                'git merge-base HEAD origin/main': 'mb',
+                'git diff --name-only mb HEAD': 'shared.ts\ncommitted-only.ts',
+            },
+        });
+        const signals = deriveHandshakeStartupSignals(CWD, {}, deps);
+        const paths = signals.changedPaths ?? [];
+        expect(paths).toContain('dirty-only.ts');
+        expect(paths).toContain('committed-only.ts');
+        // 'shared.ts' appears in BOTH sources but only once after dedupe.
+        expect(paths.filter((p) => p === 'shared.ts')).toHaveLength(1);
+    });
+    it('Codex@665: missing origin/main merge-base falls back gracefully to dirty paths only', () => {
+        const deps = makeDeps({
+            git: {
+                'git branch --show-current': 'b',
+                'git rev-parse --short HEAD': 'c',
+                'git diff --name-only HEAD': 'only-dirty.ts',
+                'git merge-base HEAD origin/main': undefined, // no origin/main
+            },
+        });
+        const signals = deriveHandshakeStartupSignals(CWD, {}, deps);
+        expect(signals.changedPaths).toEqual(['only-dirty.ts']);
+    });
+    // ── Codex@704: empty-evidence still yields an attribution envelope ──────────
+    it('Codex@704: empty-evidence handshake still returns a signals object with attribution fields', () => {
+        // No task, no scope, no refs, no changed paths — but git still attributes.
+        const deps = makeDeps({
+            git: {
+                'git branch --show-current': 'lonely-branch',
+                'git rev-parse --short HEAD': 'cafef00d',
+                // no dirty paths, no merge-base
+            },
+        });
+        const signals = deriveHandshakeStartupSignals(CWD, {}, deps);
+        // NOT {} — the envelope must carry attribution so a domain-unresolved
+        // startup row is emitted and queryable.
+        expect(Object.keys(signals).length).toBeGreaterThan(0);
+        expect(signals.resolverVersion).toBeDefined();
+        expect(signals.branchName).toBe('lonely-branch');
+        expect(signals.commitSha).toBe('cafef00d');
+        // No fabricated evidence — there is genuinely none.
+        expect(signals.changedPaths ?? []).toHaveLength(0);
+        expect(signals.reviewedArtifactRefs ?? []).toHaveLength(0);
+        expect(signals.taskText).toBeUndefined();
+    });
+    it('Codex@704: even with zero git facts the envelope still carries resolverVersion + sourceSurface', () => {
+        const deps = makeDeps({ git: {} }); // every git command fails
+        const signals = deriveHandshakeStartupSignals(CWD, {}, deps);
+        expect(signals.resolverVersion).toBeDefined();
+        expect(signals.sourceSurface).toBe('cli');
+    });
+    // ── Codex@677: briefing refs not starved by broad context cap ───────────────
+    it('Codex@677: a context.md with >=25 IDs still lets a distinct briefing.md ref through', () => {
+        // 25 distinct DEC ids in the broad context file.
+        const contextIds = Array.from({ length: 30 }, (_, i) => `DEC-${1000 + i}`).join(' ');
+        vfs[join(CWD, '.productbrain', 'context.md')] = `Context: ${contextIds}\n`;
+        // A task-specific briefing carrying a ref that does NOT appear in context.
+        vfs[join(CWD, '.productbrain', 'briefing.md')] = 'Briefing for WP-462 — see DEC-9999.\n';
+        const deps = makeDeps({
+            git: {
+                'git branch --show-current': 'wp462-rcrt-activation',
+                'git rev-parse --short HEAD': 'abc',
+            },
+        });
+        const signals = deriveHandshakeStartupSignals(CWD, {}, deps);
+        const refs = signals.reviewedArtifactRefs ?? [];
+        // The briefing-specific refs survive despite the flood of context IDs.
+        expect(refs).toContain('WP-462');
+        expect(refs).toContain('DEC-9999');
+    });
+});
 //# sourceMappingURL=handshake.test.js.map