@productbrain/cli 0.1.0-beta.5984 → 0.1.0-beta.5993

package/dist/__tests__/handshake.e2e.test.js

@@ -13,17 +13,16 @@
  *     - drift report classification (3 buckets) is correct for the fixture,
  *     - PB-managed projection paths are inside the perimeter,
  *     - user-owned files are NEVER touched,
- *     - lock metadata in the manifest is read+honoured by the perimeter,
- *     - dormant markers are idempotent across re-runs.
+ *     - lock metadata in the manifest is read+honoured by the perimeter.
  *
  *   The four rows share ONE tempdir (per spec) — failures localize to the
  *   `transitionName` column.
  */
-import { mkdtempSync, rmSync, mkdirSync, readFileSync, writeFileSync, existsSync, renameSync } from 'fs';
+import { mkdtempSync, rmSync, mkdirSync, readFileSync, writeFileSync, existsSync } from 'fs';
 import { tmpdir } from 'os';
 import { join, dirname } from 'path';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { classifyDriftBucket, DORMANT_MARKER, writeDormantMarkerToFile, } from '../commands/handshake.js';
+import { classifyDriftBucket, } from '../commands/handshake.js';
 import { MARKER } from '../generators/adapters.js';
 import { assertSetupWritePath, SETUP_PERIMETER_VIOLATION } from '../setup/perimeter.js';
 import { readManifestStatus } from '../generators/manifest.js';
@@ -97,28 +96,24 @@ const ROWS = [
         fromMode: 'off',
         toMode: 'observe',
         writesProjections: false,
-        lowersToDormant: false,
     },
     {
         transitionName: 'observe → project',
         fromMode: 'observe',
         toMode: 'project',
         writesProjections: true,
-        lowersToDormant: false,
     },
     {
         transitionName: 'project → govern',
         fromMode: 'project',
         toMode: 'govern',
         writesProjections: true,
-        lowersToDormant: false,
     },
     {
         transitionName: 'govern → off',
         fromMode: 'govern',
         toMode: 'off',
         writesProjections: false,
-        lowersToDormant: true,
     },
 ];
 // ── Per-row assertions ───────────────────────────────────────────────────────
@@ -173,39 +168,13 @@ describe('WP-421 S7 — table-driven E2E (doneWhen #27): four authority transiti
         it('user-owned file is untouched after the transition (no MARKER, never written)', () => {
             // Per row 2 (observe → project): "PB-managed projected, user-owned untouched."
             // We assert the same invariant on every row — user-owned never gains a
-            // MARKER, never gains a dormant marker, never gets overwritten.
+            // MARKER, never gets overwritten.
             const userOwnedPath = join(process.cwd(), FIXTURE_FILES.userOwned);
             const before = readFileSync(userOwnedPath, 'utf8');
-            // Simulate "what would PB do?" — try to drop a dormant marker. The
-            // function must skip user-owned files (no MARKER → return 'skipped').
-            const dormantResult = writeDormantMarkerToFile(userOwnedPath);
-            expect(dormantResult).toBe('skipped');
             const after = readFileSync(userOwnedPath, 'utf8');
             expect(after).toBe(before);
             expect(after.includes(MARKER)).toBe(false);
-            expect(after.includes(DORMANT_MARKER)).toBe(false);
         });
-        if (row.lowersToDormant) {
-            it('govern → off: dormant markers are placed on PB-managed files, idempotent on re-run', () => {
-                // Row 4 only. govern → off lowers all assets to dormant. The marker
-                // must be written exactly once even if the handshake runs N times in
-                // a row (doneWhen #20 idempotency).
-                const cleanPath = join(process.cwd(), FIXTURE_FILES.pbManagedClean);
-                // First call: marker is appended.
-                const first = writeDormantMarkerToFile(cleanPath);
-                expect(first).toBe('written');
-                // Second + third call: idempotent — must NOT append a second marker.
-                const second = writeDormantMarkerToFile(cleanPath);
-                const third = writeDormantMarkerToFile(cleanPath);
-                expect(second).toBe('already-dormant');
-                expect(third).toBe('already-dormant');
-                const content = readFileSync(cleanPath, 'utf8');
-                // Exactly one occurrence of DORMANT_MARKER.
-                const escaped = DORMANT_MARKER.replace(/[<>!-]/g, '\\$&');
-                const occurrences = (content.match(new RegExp(escaped, 'g')) ?? []).length;
-                expect(occurrences).toBe(1);
-            });
-        }
         if (row.transitionName === 'project → govern') {
             it('project → govern: lock metadata in manifest survives the transition (.lock honored)', () => {
                 // The manifest declares SETUP-RULE-PB-ORIENT: platform. This is the
@@ -515,741 +484,4 @@ describe('WP-426 E3 (Loop fix): runHandshake round-trip — authoringPath lands
         expect(allStderr).not.toContain('could not dormant-mark');
     });
 });
-// ── WP-426 E4: lowering — .dormant rename + purge cue + authoring copy untouched ─
-//
-// Drives runHandshake() with a kernel stub that returns the Foo asset in
-// dormantAssets. Pre-places the projected surface files (with MARKER) and the
-// .productbrain authoring copy. After runHandshake({apply:true}):
-//   - .codex/skills/Foo.md.dormant  ← renamed from .codex/skills/Foo.md
-//   - .cursor/rules/Foo.mdc.dormant ← renamed from .cursor/rules/Foo.mdc
-//   - originals (.md / .mdc) are gone
-//   - .productbrain/skills/Foo.md is UNTOUCHED (deriveDormantFilePaths never returns .productbrain paths)
-//   - stdout contains the purge cue
-//
-// Manual reactivation:
-//   After the lowering run, simulate the user renaming .codex/skills/Foo.md.dormant
-//   back to .codex/skills/Foo.md. Re-run with the asset still dormant. Assert:
-//   - .codex/skills/Foo.md is untouched (no re-dormant)
-//   - a drift TEN was queued via kernelCallWithSession('chain.createEntry', …)
-describe('WP-426 E4: lowering — .dormant rename + purge cue + authoring copy untouched', () => {
-    let e2eRoot;
-    let cwdSpy;
-    let stdoutLines;
-    let kernelCallWithSessionMock;
-    // ── Shared stub factory ───────────────────────────────────────────────────
-    async function setupMocks(opts = {}) {
-        vi.resetModules();
-        e2eRoot = mkdtempSync(join(tmpdir(), 'pb-wp426-e4-lower-'));
-        mkdirSync(join(e2eRoot, '.productbrain', 'skills'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.codex', 'skills'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.cursor', 'rules'), { recursive: true });
-        // Real manifest.yaml — mode='project' so writeMode is active
-        writeFileSync(join(e2eRoot, '.productbrain', 'manifest.yaml'), ['version: "0.1"', 'materialize: project', 'surfaces:', '  - .codex', '  - .cursor', '  - .claude', ''].join('\n'));
-        cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(e2eRoot);
-        stdoutLines = [];
-        vi.spyOn(process.stdout, 'write').mockImplementation((chunk, ...rest) => {
-            if (typeof chunk === 'string')
-                stdoutLines.push(chunk);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return process.stdout.write.__originalImpl ? true : true;
-        });
-        kernelCallWithSessionMock = vi.fn().mockResolvedValue(null);
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockImplementation(async (tool) => {
-                if (tool === 'chain.workspaceReadiness')
-                    return null;
-                if (tool === 'chain.getOrientView')
-                    return null;
-                if (tool === 'chain.searchEntries')
-                    return [];
-                if (tool === 'setup.listAssetsForUser') {
-                    return {
-                        activeAssets: opts.activeAssets ?? [],
-                        dormantAssets: opts.dormantAssets ?? [
-                            {
-                                entryId: 'SETUP-SKILL-FOO',
-                                name: 'Foo',
-                                description: 'A dormant skill',
-                                body: '# Foo\nSkill body.',
-                                triggers: [],
-                                assetKind: 'skill',
-                                semanticRefs: [],
-                                disabledByOwner: false,
-                                lastProjectedHash: null,
-                            },
-                            {
-                                entryId: 'SETUP-RULE-FOO',
-                                name: 'Foo',
-                                description: 'A dormant rule',
-                                body: '# Foo\nRule body.',
-                                triggers: [],
-                                assetKind: 'rule',
-                                semanticRefs: [],
-                                disabledByOwner: false,
-                                lastProjectedHash: null,
-                            },
-                        ],
-                        hasAnyReceipt: true,
-                    };
-                }
-                if (tool === 'setup.updateLastProjectedHash')
-                    return { ok: true };
-                if (tool === 'setup.getCurrentSetupState')
-                    return { effectiveMode: 'project' };
-                if (tool === 'setup.materializeSetup')
-                    return { ok: true, assetCount: 0, receiptWritten: true };
-                return null;
-            }),
-            kernelCallWithSession: kernelCallWithSessionMock,
-        }));
-        vi.doMock('../lib/config.js', () => ({
-            getConfigOrGuide: vi.fn().mockResolvedValue({ apiKey: 'pb_sk_e2e_test', siteUrl: 'https://test.convex.site' }),
-        }));
-        vi.doMock('../lib/repo-detect.js', () => ({
-            detectRepo: vi.fn().mockReturnValue({ name: 'e2e-test-repo', detectedStack: [], repoSlug: null }),
-            extractWorkspaceProfile: vi.fn().mockReturnValue(null),
-        }));
-        vi.doMock('../generators/adapters.js', () => ({
-            MARKER: 'auto-generated by pb handshake',
-            generateAgentsMd: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\nagents'),
-            generateClaudeMd: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\nclaude'),
-            generateCursorMdc: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\ncursor'),
-            generateCopilotMd: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\ncopilot'),
-            generateCopilotInstructionFiles: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock('../generators/portable-knowledge.js', () => ({
-            readCanonicalSkills: vi.fn().mockReturnValue([]),
-            readCanonicalRules: vi.fn().mockReturnValue([]),
-            readPersonalLayer: vi.fn().mockReturnValue([]),
-            readPersonalSkillsLayer: vi.fn().mockReturnValue([]),
-            generateCursorSkill: vi.fn().mockReturnValue(''),
-            generateCursorRule: vi.fn().mockReturnValue(''),
-            generateCodexSkill: vi.fn().mockReturnValue(''),
-            generateClaudeRule: vi.fn().mockReturnValue(''),
-            generateCodexSkillIndex: vi.fn().mockReturnValue(''),
-            generateClaudeSkillRouter: vi.fn().mockReturnValue(''),
-            shouldEmitToTarget: vi.fn().mockReturnValue(false),
-            filterByLevel: vi.fn().mockImplementation((items) => items),
-            evaluateConditions: vi.fn().mockReturnValue({ included: true, reasons: [] }),
-            validateCodexSkills: vi.fn().mockReturnValue([]),
-            STAGE_TO_MAX_LEVEL: {},
-            LEVEL_ORDER: [],
-        }));
-        vi.doMock('../generators/briefing-md.js', () => ({ generateBriefingMd: vi.fn().mockReturnValue('briefing') }));
-        vi.doMock('../generators/context-md.js', () => ({ generateContextMd: vi.fn().mockReturnValue('context') }));
-        vi.doMock('../generators/chain-rules.js', () => ({
-            generateChainRules: vi.fn().mockResolvedValue({ content: '', rules: [], classified: {}, stats: { generatedRules: 0, suppressedByManual: 0, suppressedByZeroEntries: 0 }, gaps: [], sentinel: null }),
-        }));
-        vi.doMock('../generators/handshake-diff.js', () => ({
-            saveHandshakeState: vi.fn(),
-            loadPreviousState: vi.fn().mockReturnValue(null),
-            diffHandshakeState: vi.fn().mockReturnValue({ added: [], updated: [], removed: [] }),
-            formatDiff: vi.fn().mockReturnValue(''),
-            buildCurrentState: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock('../generators/surface-profiles.js', () => ({
-            resolveSurfaceProfile: vi.fn().mockReturnValue({ level: 'intermediate' }),
-        }));
-        vi.doMock('../generators/boundary-manifest.js', () => ({
-            generateBoundaryManifest: vi.fn().mockReturnValue(null),
-            getBoundaryEnforcementMode: vi.fn().mockReturnValue('advisory'),
-        }));
-        vi.doMock('../formatters/handshake.js', () => ({ formatHandshakeReport: vi.fn().mockReturnValue('') }));
-        vi.doMock('../lib/hook-intents.js', () => ({
-            composeHooksFromIntents: vi.fn().mockReturnValue({}),
-            getHookStatusForSurface: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock('../lib/method-registry.js', () => ({
-            loadMethodRegistry: vi.fn().mockResolvedValue({ methods: [], source: 'bundled', stale: false }),
-        }));
-        vi.doMock('../lib/workspaceVocabCache.js', () => ({ getOrFetchVocabCtx: vi.fn().mockResolvedValue(null) }));
-        vi.doMock('../lib/telemetry.js', () => ({ trackEvent: vi.fn() }));
-        vi.doMock('../lib/session.js', () => ({
-            readSession: vi.fn().mockReturnValue({ sessionId: 'test-session-id', userId: 'test-user' }),
-        }));
-        vi.doMock('../lib/canonicalRefs.js', () => ({
-            parseSemanticRefs: vi.fn().mockReturnValue([]),
-            replaceVocabTokens: vi.fn().mockImplementation((content) => content),
-        }));
-        vi.doMock('../surfaces/telemetry.js', () => ({
-            getReverseMapFallbackMessage: vi.fn().mockReturnValue(''),
-            reportReverseMapMissing: vi.fn(),
-        }));
-    }
-    afterEach(() => {
-        cwdSpy?.mockRestore();
-        if (e2eRoot && existsSync(e2eRoot))
-            rmSync(e2eRoot, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('E4: lowering — .dormant files created for ALL surface paths (skill + rule), originals gone, authoring copy untouched, purge cue in stdout', async () => {
-        await setupMocks();
-        // FIX 3: pre-place ALL four surface paths that deriveDormantFilePaths emits
-        // for the two dormant assets (skill "Foo" + rule "Foo"):
-        //   skill → .cursor/skills/Foo/SKILL.md  (cursor skill subdir)
-        //         + .codex/skills/Foo.md          (codex skill)
-        //   rule  → .cursor/rules/Foo.mdc         (cursor rule)
-        //         + .claude/rules/Foo.md          (claude rule)
-        mkdirSync(join(e2eRoot, '.cursor', 'skills', 'Foo'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.claude', 'rules'), { recursive: true });
-        const cursorSkillPath = join(e2eRoot, '.cursor', 'skills', 'Foo', 'SKILL.md');
-        const codexSkillPath = join(e2eRoot, '.codex', 'skills', 'Foo.md');
-        const cursorRulePath = join(e2eRoot, '.cursor', 'rules', 'Foo.mdc');
-        const claudeRulePath = join(e2eRoot, '.claude', 'rules', 'Foo.md');
-        const authoringCopy = join(e2eRoot, '.productbrain', 'skills', 'Foo.md');
-        const markedContent = (label) => `<!-- auto-generated by pb handshake -->\n# Foo ${label}\n`;
-        writeFileSync(cursorSkillPath, markedContent('cursor-skill'));
-        writeFileSync(codexSkillPath, markedContent('codex-skill'));
-        writeFileSync(cursorRulePath, markedContent('cursor-rule'));
-        writeFileSync(claudeRulePath, markedContent('claude-rule'));
-        writeFileSync(authoringCopy, '---\nid: SETUP-SKILL-FOO\nname: "Foo"\n---\nHand-authored content.\n');
-        const { runHandshake } = await import('../commands/handshake.js');
-        await runHandshake({ apply: true });
-        // ── All four .dormant files must be created
-        expect(existsSync(`${cursorSkillPath}.dormant`), '.cursor/skills/Foo/SKILL.md.dormant must exist').toBe(true);
-        expect(existsSync(`${codexSkillPath}.dormant`), '.codex/skills/Foo.md.dormant must exist').toBe(true);
-        expect(existsSync(`${cursorRulePath}.dormant`), '.cursor/rules/Foo.mdc.dormant must exist').toBe(true);
-        expect(existsSync(`${claudeRulePath}.dormant`), '.claude/rules/Foo.md.dormant must exist').toBe(true);
-        // ── All four originals must be gone
-        expect(existsSync(cursorSkillPath), '.cursor/skills/Foo/SKILL.md original must be gone').toBe(false);
-        expect(existsSync(codexSkillPath), '.codex/skills/Foo.md original must be gone').toBe(false);
-        expect(existsSync(cursorRulePath), '.cursor/rules/Foo.mdc original must be gone').toBe(false);
-        expect(existsSync(claudeRulePath), '.claude/rules/Foo.md original must be gone').toBe(false);
-        // ── .productbrain authoring copy must be untouched
-        expect(existsSync(authoringCopy), '.productbrain/skills/Foo.md authoring copy must be untouched').toBe(true);
-        // ── purge cue in stdout
-        const allOutput = stdoutLines.join('');
-        expect(allOutput, 'stdout must contain the purge cue').toContain('pb setup observe --purge');
-        // ── .authoring-sync.json dormantRenamed registry must include all four surface paths
-        const syncPath = join(e2eRoot, '.productbrain', '.authoring-sync.json');
-        expect(existsSync(syncPath), '.authoring-sync.json must exist').toBe(true);
-        const syncState = JSON.parse(readFileSync(syncPath, 'utf8'));
-        expect(syncState.dormantRenamed, 'dormantRenamed must include cursor skill subdir path').toContain('.cursor/skills/Foo/SKILL.md');
-        expect(syncState.dormantRenamed, 'dormantRenamed must include codex skill path').toContain('.codex/skills/Foo.md');
-        expect(syncState.dormantRenamed, 'dormantRenamed must include cursor rule path').toContain('.cursor/rules/Foo.mdc');
-        expect(syncState.dormantRenamed, 'dormantRenamed must include claude rule path').toContain('.claude/rules/Foo.md');
-    });
-    it('E4: manual reactivation — reactivated file left untouched, drift TEN queued ONCE; N+3 run never re-dormants', async () => {
-        // FIX 2: Strengthened reactivation test.
-        // Run N+1 (detection): pre-staged state → TEN fires, path moves to dormantReactivated.
-        // Run N+2 (hands-off): path in dormantReactivated → skipped silently, file still live, NO second TEN.
-        await setupMocks();
-        const skillPath = join(e2eRoot, '.codex', 'skills', 'Foo.md');
-        // ── Pre-stage a post-lowering filesystem state:
-        //    • .codex/skills/Foo.md.dormant exists (was previously lowered)
-        //    • .productbrain/.authoring-sync.json already has the registry entry
-        //    • The user has then renamed .dormant back to .md (manual reactivation)
-        //
-        // We do NOT run a first handshake — we directly write the state that would
-        // exist after a prior lowering run. This avoids module-reset issues between
-        // two sequential runHandshake calls in the same test.
-        // .dormant file from prior lowering (user will "manually rename" it back)
-        writeFileSync(`${skillPath}.dormant`, '<!-- auto-generated by pb handshake -->\n# Foo\nSkill body.\n<!-- pb-status: dormant -->\n');
-        // Simulate user renaming .dormant → live (manual reactivation)
-        renameSync(`${skillPath}.dormant`, skillPath);
-        expect(existsSync(skillPath)).toBe(true);
-        expect(existsSync(`${skillPath}.dormant`)).toBe(false);
-        // Pre-write the .authoring-sync.json registry as if the prior lowering run had done it.
-        // Only skill path in dormantRenamed; no dormantReactivated yet.
-        const syncPath = join(e2eRoot, '.productbrain', '.authoring-sync.json');
-        writeFileSync(syncPath, JSON.stringify({
-            version: 1,
-            assets: {},
-            dormantRenamed: ['.codex/skills/Foo.md', '.cursor/rules/Foo.mdc'],
-            dormantReactivated: [],
-        }, null, 2) + '\n');
-        // Also ensure the rule .dormant is present (not manually reactivated, only the skill was)
-        mkdirSync(join(e2eRoot, '.cursor', 'rules'), { recursive: true });
-        const ruleDormantPath = join(e2eRoot, '.cursor', 'rules', 'Foo.mdc.dormant');
-        writeFileSync(ruleDormantPath, '<!-- auto-generated by pb handshake -->\n# Foo\nRule body.\n<!-- pb-status: dormant -->\n');
-        // ── Run N+1: FIRST detection of manual reactivation
-        const { runHandshake: runHandshake1 } = await import('../commands/handshake.js');
-        await runHandshake1({ apply: true });
-        // ── After N+1: reactivated file must remain live
-        expect(existsSync(skillPath), 'N+1: .codex/skills/Foo.md must remain live (user reactivated it)').toBe(true);
-        expect(existsSync(`${skillPath}.dormant`), 'N+1: .dormant must NOT be recreated for the reactivated file').toBe(false);
-        // ── After N+1: .authoring-sync.json must have path in dormantReactivated, not dormantRenamed (FIX 2a)
-        const syncState1 = JSON.parse(readFileSync(syncPath, 'utf8'));
-        expect(syncState1.dormantReactivated, 'N+1: dormantReactivated must include the reactivated skill path').toContain('.codex/skills/Foo.md');
-        expect(syncState1.dormantRenamed ?? [], 'N+1: dormantRenamed must NOT include the reactivated skill path').not.toContain('.codex/skills/Foo.md');
-        // ── After N+1: exactly one drift TEN was queued
-        const createEntryCalls1 = kernelCallWithSessionMock.mock.calls.filter((call) => call[0] === 'chain.createEntry');
-        expect(createEntryCalls1.length, 'N+1: at least one chain.createEntry call (drift TEN) must be made').toBeGreaterThan(0);
-        const driftCall1 = createEntryCalls1.find((call) => {
-            const args = call[1];
-            return (args.collectionSlug === 'tensions' &&
-                typeof args.data?.description === 'string' &&
-                args.data.description.includes('manually reactivated'));
-        });
-        expect(driftCall1, 'N+1: drift TEN for manual reactivation must be queued').toBeDefined();
-        const tenCountAfterN1 = createEntryCalls1.filter((call) => {
-            const args = call[1];
-            return (args.collectionSlug === 'tensions' &&
-                args.data.description?.includes('manually reactivated'));
-        }).length;
-        // ── Run N+2 (FIX 2b): asset still dormant, path now in dormantReactivated.
-        //    The hands-off set must prevent any re-dormant AND any second TEN.
-        vi.resetModules();
-        // Re-setup mocks for the second run (fresh module registry)
-        await setupMocks();
-        // Restore the .authoring-sync.json state that N+1 left (setupMocks creates a fresh e2eRoot, so we must
-        // re-use the same root by restoring after setupMocks overwrites it).
-        // Since setupMocks creates a new e2eRoot, we need to write the N+1 post-state into the new root.
-        // Instead, we directly write the dormantReactivated state to simulate what N+1 wrote.
-        writeFileSync(skillPath, '<!-- auto-generated by pb handshake -->\n# Foo\nSkill body.\n');
-        writeFileSync(syncPath, JSON.stringify({
-            version: 1,
-            assets: {},
-            dormantRenamed: ['.cursor/rules/Foo.mdc'], // skill moved out
-            dormantReactivated: ['.codex/skills/Foo.md'], // skill in hands-off set
-        }, null, 2) + '\n');
-        // Rule dormant still present (untouched)
-        writeFileSync(join(e2eRoot, '.cursor', 'rules', 'Foo.mdc.dormant'), '<!-- auto-generated by pb handshake -->\n# Foo\nRule body.\n<!-- pb-status: dormant -->\n');
-        const { runHandshake: runHandshake2 } = await import('../commands/handshake.js');
-        await runHandshake2({ apply: true });
-        // ── After N+2: skill file must STILL be live (not re-dormanted)
-        expect(existsSync(skillPath), 'N+2: .codex/skills/Foo.md must still be live (hands-off set)').toBe(true);
-        expect(existsSync(`${skillPath}.dormant`), 'N+2: .dormant must NOT be created on the second run').toBe(false);
-        // ── After N+2: NO new drift TEN for the already-reactivated path (TEN fires once)
-        const createEntryCalls2 = kernelCallWithSessionMock.mock.calls.filter((call) => call[0] === 'chain.createEntry');
-        const newReactivationTens = createEntryCalls2.filter((call) => {
-            const args = call[1];
-            return (args.collectionSlug === 'tensions' &&
-                args.data.description?.includes('manually reactivated'));
-        }).length;
-        expect(newReactivationTens, 'N+2: no additional reactivation TEN must be queued (hands-off set; TEN fires once)').toBe(0);
-    });
-    // Codex P2: dormant renames must honor the run's --surfaces selection, not just the
-    // perimeter. `--surfaces cursor` may only rename cursor surfaces; .claude/.codex must
-    // be left untouched even though they are declared in manifest.surfaces.
-    it('E4 (Codex P2): --surfaces cursor lowers only cursor surfaces; .claude/.codex untouched', async () => {
-        await setupMocks();
-        mkdirSync(join(e2eRoot, '.cursor', 'skills', 'Foo'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.claude', 'rules'), { recursive: true });
-        const cursorSkillPath = join(e2eRoot, '.cursor', 'skills', 'Foo', 'SKILL.md');
-        const codexSkillPath = join(e2eRoot, '.codex', 'skills', 'Foo.md');
-        const cursorRulePath = join(e2eRoot, '.cursor', 'rules', 'Foo.mdc');
-        const claudeRulePath = join(e2eRoot, '.claude', 'rules', 'Foo.md');
-        const marked = (label) => `<!-- auto-generated by pb handshake -->\n# Foo ${label}\n`;
-        writeFileSync(cursorSkillPath, marked('cursor-skill'));
-        writeFileSync(codexSkillPath, marked('codex-skill'));
-        writeFileSync(cursorRulePath, marked('cursor-rule'));
-        writeFileSync(claudeRulePath, marked('claude-rule'));
-        const { runHandshake } = await import('../commands/handshake.js');
-        await runHandshake({ apply: true, surfaces: ['cursor'] });
-        // ── cursor surfaces lowered to .dormant
-        expect(existsSync(`${cursorSkillPath}.dormant`), 'cursor skill must be lowered').toBe(true);
-        expect(existsSync(`${cursorRulePath}.dormant`), 'cursor rule must be lowered').toBe(true);
-        expect(existsSync(cursorSkillPath), 'cursor skill original gone').toBe(false);
-        expect(existsSync(cursorRulePath), 'cursor rule original gone').toBe(false);
-        // ── non-requested surfaces left fully untouched (no .dormant, originals intact)
-        expect(existsSync(`${codexSkillPath}.dormant`), 'codex must NOT be lowered (--surfaces cursor)').toBe(false);
-        expect(existsSync(`${claudeRulePath}.dormant`), 'claude must NOT be lowered (--surfaces cursor)').toBe(false);
-        expect(existsSync(codexSkillPath), 'codex skill original intact').toBe(true);
-        expect(existsSync(claudeRulePath), 'claude rule original intact').toBe(true);
-    });
-});
-// ── WP-426 E4: raise — orphan .dormant removed after re-projection; drift on edited copy ─
-//
-// Drives runHandshake() with a kernel stub. The raise-cleanup pass runs in the
-// `if (writeMode)` block after the dormant pass. It iterates over active assets,
-// calls deriveDormantFilePaths, and runs restoreSurfaceFromDormant(filePath).
-//
-// restoreSurfaceFromDormant compares the EXISTING fresh projection on disk against
-// the .dormant copy. In the real flow, the write loop re-projects the surface fresh
-// before the raise pass runs. In the test, we pre-place the fresh .md to simulate
-// what the write loop does (since readCanonicalSkills returns [] in these tests, the
-// write loop doesn't write .codex/skills/*.md via the codex skill loop).
-//
-// Test structure:
-//   1. Two-pass roundtrip: lower via runHandshake (pass 1) → pre-place fresh .md →
-//      raise via runHandshake (pass 2). Assert .md exists, .dormant gone.
-//   2. Edited variant: pre-place edited .dormant + fresh .md → runHandshake →
-//      assert .dormant preserved + drift TEN queued.
-//   3. Both-registries prune: pre-place with path in both dormantRenamed AND
-//      dormantReactivated → raise → assert both pruned.
-describe('WP-426 E4: raise — orphan .dormant removed, drift on edited copy, both registries pruned', () => {
-    let e2eRoot;
-    let cwdSpy;
-    let kernelCallWithSessionMock;
-    // ── Shared mock setup factory — mirrors the E4 lowering pattern ──────────
-    async function setupRaiseMocks(opts = {}) {
-        vi.resetModules();
-        e2eRoot = mkdtempSync(join(tmpdir(), 'pb-wp426-e4-raise-'));
-        mkdirSync(join(e2eRoot, '.productbrain', 'skills'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.codex', 'skills'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.cursor', 'rules'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.cursor', 'skills', 'Foo'), { recursive: true });
-        mkdirSync(join(e2eRoot, '.claude', 'rules'), { recursive: true });
-        // Real manifest — mode='project' so writeMode is active
-        writeFileSync(join(e2eRoot, '.productbrain', 'manifest.yaml'), ['version: "0.1"', 'materialize: project', 'surfaces:', '  - .codex', '  - .cursor', '  - .claude', ''].join('\n'));
-        cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(e2eRoot);
-        vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        kernelCallWithSessionMock = vi.fn().mockResolvedValue(null);
-        vi.doMock('../lib/client.js', () => ({
-            kernelCall: vi.fn().mockImplementation(async (tool) => {
-                if (tool === 'chain.workspaceReadiness')
-                    return null;
-                if (tool === 'chain.getOrientView')
-                    return null;
-                if (tool === 'chain.searchEntries')
-                    return [];
-                if (tool === 'setup.listAssetsForUser') {
-                    return {
-                        activeAssets: opts.activeAssets ?? [],
-                        dormantAssets: opts.dormantAssets ?? [],
-                        hasAnyReceipt: true,
-                    };
-                }
-                if (tool === 'setup.updateLastProjectedHash')
-                    return { ok: true };
-                if (tool === 'setup.getCurrentSetupState')
-                    return { effectiveMode: 'project' };
-                if (tool === 'setup.materializeSetup')
-                    return { ok: true, assetCount: 0, receiptWritten: true };
-                return null;
-            }),
-            kernelCallWithSession: kernelCallWithSessionMock,
-        }));
-        vi.doMock('../lib/config.js', () => ({
-            getConfigOrGuide: vi.fn().mockResolvedValue({ apiKey: 'pb_sk_e2e_test', siteUrl: 'https://test.convex.site' }),
-        }));
-        vi.doMock('../lib/repo-detect.js', () => ({
-            detectRepo: vi.fn().mockReturnValue({ name: 'e2e-test-repo', detectedStack: [], repoSlug: null }),
-            extractWorkspaceProfile: vi.fn().mockReturnValue(null),
-        }));
-        vi.doMock('../generators/adapters.js', () => ({
-            MARKER: 'auto-generated by pb handshake',
-            generateAgentsMd: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\nagents'),
-            generateClaudeMd: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\nclaude'),
-            generateCursorMdc: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\ncursor'),
-            generateCopilotMd: vi.fn().mockReturnValue('<!-- auto-generated by pb handshake -->\ncopilot'),
-            generateCopilotInstructionFiles: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock('../generators/portable-knowledge.js', () => ({
-            readCanonicalSkills: vi.fn().mockReturnValue([]),
-            readCanonicalRules: vi.fn().mockReturnValue([]),
-            readPersonalLayer: vi.fn().mockReturnValue([]),
-            readPersonalSkillsLayer: vi.fn().mockReturnValue([]),
-            generateCursorSkill: vi.fn().mockReturnValue(''),
-            generateCursorRule: vi.fn().mockReturnValue(''),
-            generateCodexSkill: vi.fn().mockReturnValue(''),
-            generateClaudeRule: vi.fn().mockReturnValue(''),
-            generateCodexSkillIndex: vi.fn().mockReturnValue(''),
-            generateClaudeSkillRouter: vi.fn().mockReturnValue(''),
-            shouldEmitToTarget: vi.fn().mockReturnValue(false),
-            filterByLevel: vi.fn().mockImplementation((items) => items),
-            evaluateConditions: vi.fn().mockReturnValue({ included: true, reasons: [] }),
-            validateCodexSkills: vi.fn().mockReturnValue([]),
-            STAGE_TO_MAX_LEVEL: {},
-            LEVEL_ORDER: [],
-        }));
-        vi.doMock('../generators/briefing-md.js', () => ({ generateBriefingMd: vi.fn().mockReturnValue('briefing') }));
-        vi.doMock('../generators/context-md.js', () => ({ generateContextMd: vi.fn().mockReturnValue('context') }));
-        vi.doMock('../generators/chain-rules.js', () => ({
-            generateChainRules: vi.fn().mockResolvedValue({ content: '', rules: [], classified: {}, stats: { generatedRules: 0, suppressedByManual: 0, suppressedByZeroEntries: 0 }, gaps: [], sentinel: null }),
-        }));
-        vi.doMock('../generators/handshake-diff.js', () => ({
-            saveHandshakeState: vi.fn(),
-            loadPreviousState: vi.fn().mockReturnValue(null),
-            diffHandshakeState: vi.fn().mockReturnValue({ added: [], updated: [], removed: [] }),
-            formatDiff: vi.fn().mockReturnValue(''),
-            buildCurrentState: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock('../generators/surface-profiles.js', () => ({
-            resolveSurfaceProfile: vi.fn().mockReturnValue({ level: 'intermediate' }),
-        }));
-        vi.doMock('../generators/boundary-manifest.js', () => ({
-            generateBoundaryManifest: vi.fn().mockReturnValue(null),
-            getBoundaryEnforcementMode: vi.fn().mockReturnValue('advisory'),
-        }));
-        vi.doMock('../formatters/handshake.js', () => ({ formatHandshakeReport: vi.fn().mockReturnValue('') }));
-        vi.doMock('../lib/hook-intents.js', () => ({
-            composeHooksFromIntents: vi.fn().mockReturnValue({}),
-            getHookStatusForSurface: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock('../lib/method-registry.js', () => ({
-            loadMethodRegistry: vi.fn().mockResolvedValue({ methods: [], source: 'bundled', stale: false }),
-        }));
-        vi.doMock('../lib/workspaceVocabCache.js', () => ({ getOrFetchVocabCtx: vi.fn().mockResolvedValue(null) }));
-        vi.doMock('../lib/telemetry.js', () => ({ trackEvent: vi.fn() }));
-        vi.doMock('../lib/session.js', () => ({
-            readSession: vi.fn().mockReturnValue({ sessionId: 'test-session-id', userId: 'test-user' }),
-        }));
-        vi.doMock('../lib/canonicalRefs.js', () => ({
-            parseSemanticRefs: vi.fn().mockReturnValue([]),
-            replaceVocabTokens: vi.fn().mockImplementation((content) => content),
-        }));
-        vi.doMock('../surfaces/telemetry.js', () => ({
-            getReverseMapFallbackMessage: vi.fn().mockReturnValue(''),
-            reportReverseMapMissing: vi.fn(),
-        }));
-    }
-    afterEach(() => {
-        cwdSpy?.mockRestore();
-        if (e2eRoot && existsSync(e2eRoot))
-            rmSync(e2eRoot, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('E4: raise roundtrip — lower via runHandshake, then raise via runHandshake; .md exists, .dormant gone, registries pruned', async () => {
-        // ── Pass 1: lower — asset in dormantAssets → .dormant rename
-        await setupRaiseMocks({
-            dormantAssets: [{
-                    entryId: 'SETUP-SKILL-FOO',
-                    name: 'Foo',
-                    description: 'A skill',
-                    body: '# Foo\nSkill body.',
-                    triggers: [],
-                    assetKind: 'skill',
-                    semanticRefs: [],
-                    disabledByOwner: false,
-                    lastProjectedHash: null,
-                }],
-            activeAssets: [],
-        });
-        const codexSkillPath = join(e2eRoot, '.codex', 'skills', 'Foo.md');
-        const syncPath = join(e2eRoot, '.productbrain', '.authoring-sync.json');
-        // Pre-place the surface file with MARKER so the lowering pass can rename it
-        writeFileSync(codexSkillPath, '<!-- auto-generated by pb handshake -->\n# Foo\nSkill body.\n');
-        const { runHandshake: runLower } = await import('../commands/handshake.js');
-        await runLower({ apply: true });
-        // Verify lowering worked: .dormant exists, original gone, registry updated
-        expect(existsSync(`${codexSkillPath}.dormant`), 'after lower: .dormant must exist').toBe(true);
-        expect(existsSync(codexSkillPath), 'after lower: original must be gone').toBe(false);
-        const syncAfterLower = JSON.parse(readFileSync(syncPath, 'utf8'));
-        expect(syncAfterLower.dormantRenamed).toContain('.codex/skills/Foo.md');
-        // ── Pass 2: raise — asset back in activeAssets; fresh .md pre-placed to simulate write loop
-        vi.resetModules();
-        const savedRoot = e2eRoot; // preserve before setupRaiseMocks might reset
-        await setupRaiseMocks({
-            activeAssets: [{
-                    entryId: 'SETUP-SKILL-FOO',
-                    name: 'Foo',
-                    description: 'A skill',
-                    body: '# Foo\nSkill body.',
-                    triggers: [],
-                    assetKind: 'skill',
-                    semanticRefs: [],
-                    disabledByOwner: false,
-                    lastProjectedHash: null,
-                    scope: 'personal',
-                }],
-            dormantAssets: [],
-        });
-        // setupRaiseMocks creates a new e2eRoot — restore the saved root so we test
-        // against the lowered FS state from pass 1.
-        rmSync(e2eRoot, { recursive: true, force: true });
-        e2eRoot = savedRoot;
-        cwdSpy.mockReturnValue(e2eRoot);
-        // Simulate what the write loop does: re-project the surface fresh.
-        // (The codex skill loop doesn't write .codex/skills/*.md in test env because
-        // readCanonicalSkills returns []; pre-placing it models the real write-loop output.)
-        writeFileSync(codexSkillPath, '<!-- auto-generated by pb handshake -->\n# Foo\nSkill body.\n');
-        const { runHandshake: runRaise } = await import('../commands/handshake.js');
-        await runRaise({ apply: true });
-        // ── .md exists, .dormant gone
-        expect(existsSync(codexSkillPath), 'after raise: .codex/skills/Foo.md must exist').toBe(true);
-        expect(existsSync(`${codexSkillPath}.dormant`), 'after raise: .dormant must be gone').toBe(false);
-        // ── dormantRenamed pruned
-        const syncAfterRaise = JSON.parse(readFileSync(syncPath, 'utf8'));
-        expect(syncAfterRaise.dormantRenamed ?? [], 'dormantRenamed must not contain the raised path').not.toContain('.codex/skills/Foo.md');
-        expect(syncAfterRaise.dormantReactivated ?? [], 'dormantReactivated must not contain the raised path').not.toContain('.codex/skills/Foo.md');
-    });
-    it('E4: raise with edited .dormant — .dormant preserved and drift TEN queued', async () => {
-        // Pre-place state: fresh .md + edited .dormant (bodies differ) → orphan-drift.
-        await setupRaiseMocks({
-            activeAssets: [{
-                    entryId: 'SETUP-SKILL-FOO',
-                    name: 'Foo',
-                    description: 'A skill',
-                    body: '# Foo\nSkill body.',
-                    triggers: [],
-                    assetKind: 'skill',
-                    semanticRefs: [],
-                    disabledByOwner: false,
-                    lastProjectedHash: null,
-                    scope: 'personal',
-                }],
-            dormantAssets: [],
-        });
-        const codexSkillPath = join(e2eRoot, '.codex', 'skills', 'Foo.md');
-        const syncPath = join(e2eRoot, '.productbrain', '.authoring-sync.json');
-        // Fresh .md (simulates write loop output)
-        writeFileSync(codexSkillPath, '<!-- auto-generated by pb handshake -->\n# Foo\nSkill body.\n');
-        // Edited .dormant — body differs from fresh → restoreSurfaceFromDormant returns 'orphan-drift'
-        writeFileSync(`${codexSkillPath}.dormant`, '<!-- auto-generated by pb handshake -->\n# Foo\nUSER EDITED CONTENT HERE.\n<!-- pb-status: dormant -->\n');
-        // Registry shows this path was previously lowered
-        writeFileSync(syncPath, JSON.stringify({
-            version: 1, assets: {}, dormantRenamed: ['.codex/skills/Foo.md'], dormantReactivated: [],
-        }, null, 2) + '\n');
-        const { runHandshake } = await import('../commands/handshake.js');
-        await runHandshake({ apply: true });
-        // .md still exists (write loop placed it; raise-cleanup doesn't remove it)
-        expect(existsSync(codexSkillPath), 'edited variant: .md must exist').toBe(true);
-        // .dormant preserved (body differs → orphan-drift)
-        expect(existsSync(`${codexSkillPath}.dormant`), 'edited variant: edited .dormant must be preserved').toBe(true);
-        // drift TEN queued
-        const driftCalls = kernelCallWithSessionMock.mock.calls.filter((call) => {
-            const args = call[1];
-            return (call[0] === 'chain.createEntry' &&
-                args.collectionSlug === 'tensions' &&
-                typeof args.data?.description === 'string' &&
-                args.data.description.includes('edited while dormant'));
-        });
-        expect(driftCalls.length, 'edited variant: drift TEN must be queued').toBeGreaterThan(0);
-    });
-    it('E4: raise also prunes dormantReactivated registry (carry-over obligation)', async () => {
-        // Pre-place fresh .md + matching .dormant (bodies match) + path in BOTH registries.
-        // After raise: .dormant removed, BOTH entries pruned.
-        await setupRaiseMocks({
-            activeAssets: [{
-                    entryId: 'SETUP-SKILL-FOO',
-                    name: 'Foo',
-                    description: 'A skill',
-                    body: '# Foo\nSkill body.',
-                    triggers: [],
-                    assetKind: 'skill',
-                    semanticRefs: [],
-                    disabledByOwner: false,
-                    lastProjectedHash: null,
-                    scope: 'personal',
-                }],
-            dormantAssets: [],
-        });
-        const codexSkillPath = join(e2eRoot, '.codex', 'skills', 'Foo.md');
-        const syncPath = join(e2eRoot, '.productbrain', '.authoring-sync.json');
-        // Fresh .md (simulates write loop output)
-        writeFileSync(codexSkillPath, '<!-- auto-generated by pb handshake -->\n# Foo\nSkill body.\n');
-        // Matching .dormant (bodies match after stripping DORMANT_MARKER)
-        writeFileSync(`${codexSkillPath}.dormant`, '<!-- auto-generated by pb handshake -->\n# Foo\nSkill body.\n<!-- pb-status: dormant -->\n');
-        // Registry: path in BOTH dormantRenamed AND dormantReactivated
-        writeFileSync(syncPath, JSON.stringify({
-            version: 1, assets: {},
-            dormantRenamed: ['.codex/skills/Foo.md'],
-            dormantReactivated: ['.codex/skills/Foo.md'],
-        }, null, 2) + '\n');
-        const { runHandshake } = await import('../commands/handshake.js');
-        await runHandshake({ apply: true });
-        // .dormant removed (bodies match)
-        expect(existsSync(`${codexSkillPath}.dormant`), 'carry-over: .dormant must be removed on raise').toBe(false);
-        // BOTH registries pruned
-        const syncAfterRaise = JSON.parse(readFileSync(syncPath, 'utf8'));
-        expect(syncAfterRaise.dormantRenamed ?? [], 'carry-over: dormantRenamed must be pruned').not.toContain('.codex/skills/Foo.md');
-        expect(syncAfterRaise.dormantReactivated ?? [], 'carry-over: dormantReactivated must be pruned').not.toContain('.codex/skills/Foo.md');
-    });
-    // Codex P1: registry pruning must happen for ANY active asset on raise — even when no
-    // .dormant sibling exists this run. A surface that was manually reactivated earlier leaves
-    // no .dormant (restoreSurfaceFromDormant → 'skipped'), but its path lingers in
-    // dormantReactivated. The old code only pruned on 'restored', so the hands-off entry was
-    // permanent and a future lowering could never re-dormant the surface. The fix prunes
-    // unconditionally for active assets.
-    it('E4 (Codex P1): raise prunes dormantReactivated even when no .dormant sibling exists', async () => {
-        await setupRaiseMocks({
-            activeAssets: [{
-                    entryId: 'SETUP-RULE-FOO',
-                    name: 'Foo',
-                    description: 'An active rule that was manually reactivated earlier (no .dormant left)',
-                    body: '# Foo\nRule body.',
-                    triggers: [],
-                    assetKind: 'rule',
-                    semanticRefs: [],
-                    disabledByOwner: false,
-                    lastProjectedHash: null,
-                    scope: 'personal',
-                }],
-            dormantAssets: [],
-        });
-        const cursorRulePath = join(e2eRoot, '.cursor', 'rules', 'Foo.mdc');
-        const claudeRulePath = join(e2eRoot, '.claude', 'rules', 'Foo.md');
-        const syncPath = join(e2eRoot, '.productbrain', '.authoring-sync.json');
-        // Live files present (asset is active + re-projected), but NO .dormant siblings:
-        // the user manually reactivated earlier, so restoreSurfaceFromDormant returns 'skipped'.
-        writeFileSync(cursorRulePath, '<!-- auto-generated by pb handshake -->\n# Foo\nRule body.\n');
-        writeFileSync(claudeRulePath, '<!-- auto-generated by pb handshake -->\n# Foo\nRule body.\n');
-        expect(existsSync(`${cursorRulePath}.dormant`), 'setup: cursor .dormant must be absent').toBe(false);
-        expect(existsSync(`${claudeRulePath}.dormant`), 'setup: claude .dormant must be absent').toBe(false);
-        // Registry still lists both paths in the hands-off set from the earlier reactivation.
-        writeFileSync(syncPath, JSON.stringify({
-            version: 1, assets: {},
-            dormantRenamed: [],
-            dormantReactivated: ['.cursor/rules/Foo.mdc', '.claude/rules/Foo.md'],
-        }, null, 2) + '\n');
-        const { runHandshake } = await import('../commands/handshake.js');
-        await runHandshake({ apply: true });
-        // The hands-off entries must be pruned even though no .dormant existed this run,
-        // so a future lowering can re-dormant the surface again.
-        const syncAfterRaise = JSON.parse(readFileSync(syncPath, 'utf8'));
-        expect(syncAfterRaise.dormantReactivated ?? [], 'cursor path must be pruned from dormantReactivated').not.toContain('.cursor/rules/Foo.mdc');
-        expect(syncAfterRaise.dormantReactivated ?? [], 'claude path must be pruned from dormantReactivated').not.toContain('.claude/rules/Foo.md');
-    });
-    // WP-426 E4 Domain Expert fix: surface-filtered raise must NOT false-flag orphan-drift
-    //
-    // Simulates a raise where the cursor surface was NOT written this run (e.g. --surfaces codex).
-    // The cursor .dormant file exists from a prior lowering, but the cursor live .md was never
-    // written back by the write loop. The raise-cleanup pass must NOT treat the absent live file
-    // as evidence of a user edit → must NOT queue an 'edited while dormant' drift TEN.
-    //
-    // Implementation: we do NOT pre-place the cursor live file, simulating a surface-filtered run
-    // where the cursor loop was skipped. The codex surface IS written (pre-placed) so a full-surface
-    // raise would succeed for codex; only cursor is left absent.
-    it('E4: surface-filtered raise — absent live file skips, no false orphan-drift TEN, .dormant preserved', async () => {
-        await setupRaiseMocks({
-            activeAssets: [{
-                    entryId: 'SETUP-RULE-FOO',
-                    name: 'Foo',
-                    description: 'A rule that is active but cursor surface was not written this run',
-                    body: '# Foo\nRule body.',
-                    triggers: [],
-                    assetKind: 'rule',
-                    semanticRefs: [],
-                    disabledByOwner: false,
-                    lastProjectedHash: null,
-                    scope: 'personal',
-                }],
-            dormantAssets: [],
-        });
-        // Cursor rule path — corresponds to deriveDormantFilePaths for assetKind:'rule'
-        const cursorRulePath = join(e2eRoot, '.cursor', 'rules', 'Foo.mdc');
-        const claudeRulePath = join(e2eRoot, '.claude', 'rules', 'Foo.md');
-        const syncPath = join(e2eRoot, '.productbrain', '.authoring-sync.json');
-        // ── Pre-place state simulating a prior lowering that created .dormant files
-        //    for both cursor and claude, then a surface-filtered raise where neither
-        //    live file was written back by the write loop (both are absent).
-        writeFileSync(`${cursorRulePath}.dormant`, '<!-- auto-generated by pb handshake -->\n# Foo\nRule body.\n<!-- pb-status: dormant -->\n');
-        writeFileSync(`${claudeRulePath}.dormant`, '<!-- auto-generated by pb handshake -->\n# Foo\nRule body.\n<!-- pb-status: dormant -->\n');
-        // Registry shows both paths were previously lowered
-        writeFileSync(syncPath, JSON.stringify({
-            version: 1, assets: {},
-            dormantRenamed: ['.cursor/rules/Foo.mdc', '.claude/rules/Foo.md'],
-            dormantReactivated: [],
-        }, null, 2) + '\n');
-        // Crucially: neither cursorRulePath nor claudeRulePath is pre-placed (surface-filtered run)
-        expect(existsSync(cursorRulePath), 'setup: cursor live file must be absent').toBe(false);
-        expect(existsSync(claudeRulePath), 'setup: claude live file must be absent').toBe(false);
-        const { runHandshake } = await import('../commands/handshake.js');
-        await runHandshake({ apply: true });
-        // ── (a) .dormant files must still be present (not cleaned up for absent live files)
-        expect(existsSync(`${cursorRulePath}.dormant`), 'surface-filtered: cursor .dormant must be preserved').toBe(true);
-        expect(existsSync(`${claudeRulePath}.dormant`), 'surface-filtered: claude .dormant must be preserved').toBe(true);
-        // ── (b) NO 'edited while dormant' drift TEN must have been queued
-        const driftCalls = kernelCallWithSessionMock.mock.calls.filter((call) => {
-            const args = call[1];
-            return (call[0] === 'chain.createEntry' &&
-                args.collectionSlug === 'tensions' &&
-                typeof args.data?.description === 'string' &&
-                args.data.description.includes('edited while dormant'));
-        });
-        expect(driftCalls.length, 'surface-filtered: no false orphan-drift TEN must be queued').toBe(0);
-        // ── (c) no orphan-drift for the absent cursor / claude surface paths
-        //    (verified by the absence of drift TEN calls above; belt-and-suspenders check)
-        expect(existsSync(cursorRulePath), 'surface-filtered: cursor live file must remain absent').toBe(false);
-        expect(existsSync(claudeRulePath), 'surface-filtered: claude live file must remain absent').toBe(false);
-        // ── (d) Codex P2: because the .dormant files still exist (restore skipped, no fresh
-        //    live file), the dormantRenamed registry evidence must be KEPT — not pruned — so a
-        //    later manual .dormant→live reactivation is still recognized as previouslyRenamed.
-        const syncAfterRaise = JSON.parse(readFileSync(syncPath, 'utf8'));
-        expect(syncAfterRaise.dormantRenamed ?? [], 'surface-filtered: cursor registry evidence must be kept').toContain('.cursor/rules/Foo.mdc');
-        expect(syncAfterRaise.dormantRenamed ?? [], 'surface-filtered: claude registry evidence must be kept').toContain('.claude/rules/Foo.md');
-    });
-});
 //# sourceMappingURL=handshake.e2e.test.js.map