@productbrain/cli 0.1.0-beta.95 → 0.1.0-beta.958

package/dist/__tests__/handshake-preview.test.js

@@ -3,6 +3,7 @@
  * STD-197: preview is the new default (no --apply flag = no writes).
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createHash } from 'crypto';
 const { vfs, MOCK_MARKER, MOCK_CWD, MOCK_HOME } = vi.hoisted(() => ({
     vfs: {},
     MOCK_MARKER: 'auto-generated by pb handshake',
@@ -22,6 +23,7 @@ vi.mock('fs', () => ({
     }),
     readdirSync: vi.fn(() => []),
     copyFileSync: vi.fn(),
+    realpathSync: vi.fn((path) => path),
 }));
 vi.mock('os', () => ({ homedir: vi.fn(() => MOCK_HOME) }));
 vi.mock('../lib/prompts.js', () => ({
@@ -33,6 +35,14 @@ vi.mock('../lib/prompts.js', () => ({
 }));
 vi.mock('../lib/client.js', () => ({
     kernelCall: vi.fn().mockResolvedValue([]),
+    kernelCallWithSession: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../lib/session.js', () => ({
+    readSession: vi.fn(() => null),
+    writeSession: vi.fn(),
+    clearSession: vi.fn(),
+    readClosedMarker: vi.fn(() => null),
+    addCapturedEntry: vi.fn(),
 }));
 vi.mock('../lib/config.js', () => ({
     getConfigOrGuide: vi.fn().mockResolvedValue({
@@ -90,6 +100,13 @@ vi.mock('../generators/surface-profiles.js', () => ({
 }));
 vi.mock('../generators/manifest.js', () => ({
     readManifest: vi.fn().mockReturnValue(null),
+    readManifestStatus: vi.fn().mockReturnValue({
+        mode: 'project',
+        surfaces: ['.cursor', '.claude', '.codex', '.github'],
+        lock: {},
+        parseStatus: 'ok',
+        manifest: null,
+    }),
     filterByAdoptionState: vi.fn().mockImplementation((items) => items),
 }));
 vi.mock('../formatters/handshake.js', () => ({
@@ -102,15 +119,29 @@ vi.mock('../lib/hook-intents.js', () => ({
 vi.mock('../lib/method-registry.js', () => ({
     loadMethodRegistry: vi.fn().mockResolvedValue({ methods: [] }),
 }));
-import { writeFileSync } from 'fs';
+import { readdirSync, writeFileSync } from 'fs';
 import { formatHandshakeReport } from '../formatters/handshake.js';
-import { kernelCall } from '../lib/client.js';
+import { kernelCall, kernelCallWithSession } from '../lib/client.js';
+import { readSession } from '../lib/session.js';
+import { readManifestStatus } from '../generators/manifest.js';
 import { generateCursorSkill, shouldEmitToTarget } from '../generators/portable-knowledge.js';
 import { runHandshake } from '../commands/handshake.js';
 function capturedReport() {
     const calls = vi.mocked(formatHandshakeReport).mock.calls;
     return calls.length > 0 ? calls[calls.length - 1][0] : null;
 }
+function setupAuthoringTestHash(asset) {
+    const canonical = {
+        entryId: asset.entryId,
+        name: asset.name,
+        description: asset.description,
+        assetKind: asset.assetKind,
+        triggers: asset.triggers ?? [],
+        semanticRefs: asset.semanticRefs ?? [],
+        body: asset.body.replace(/\r\n/g, '\n').replace(/\r/g, '\n').trimEnd(),
+    };
+    return `sha256:${createHash('sha256').update(JSON.stringify(canonical), 'utf8').digest('hex')}`;
+}
 describe('runHandshake — preview/apply/dryRun invariants (WP-332 S1)', () => {
     let cwdSpy;
     beforeEach(() => {
@@ -120,6 +151,14 @@ describe('runHandshake — preview/apply/dryRun invariants (WP-332 S1)', () => {
         vi.spyOn(console, 'log').mockImplementation(() => { });
         vi.spyOn(console, 'error').mockImplementation(() => { });
         vi.spyOn(console, 'warn').mockImplementation(() => { });
+        vi.mocked(readdirSync).mockReturnValue([]);
+        vi.mocked(readManifestStatus).mockReturnValue({
+            mode: 'project',
+            surfaces: ['.cursor', '.claude', '.codex', '.github'],
+            lock: {},
+            parseStatus: 'ok',
+            manifest: null,
+        });
     });
     afterEach(() => {
         cwdSpy.mockRestore();
@@ -136,6 +175,161 @@ describe('runHandshake — preview/apply/dryRun invariants (WP-332 S1)', () => {
         await runHandshake({ dryRun: true });
         expect(writeFileSync).not.toHaveBeenCalled();
     });
+    it('apply + observe authority is preview-only and writes nothing', async () => {
+        vi.mocked(readManifestStatus).mockReturnValue({
+            mode: 'observe',
+            surfaces: ['.cursor'],
+            lock: {},
+            parseStatus: 'ok',
+            manifest: null,
+        });
+        await runHandshake({ apply: true, surfaces: ['cursor'] });
+        expect(writeFileSync).not.toHaveBeenCalled();
+        expect(vi.mocked(kernelCall).mock.calls.some(([tool]) => tool === 'setup.materializeSetup')).toBe(false);
+        expect(capturedReport()?.filesWritten).toEqual([]);
+        expect(capturedReport()?.filesSkipped?.some((f) => f.reason === 'preview-only (materialize: observe)')).toBe(true);
+    });
+    it('apply + govern authority writes files and invokes materializeSetup (KEY-24 complement to observe)', async () => {
+        vi.mocked(readManifestStatus).mockReturnValue({
+            mode: 'govern',
+            surfaces: ['.cursor'],
+            lock: {},
+            parseStatus: 'ok',
+            manifest: null,
+        });
+        await runHandshake({ apply: true, surfaces: ['cursor'] });
+        expect(writeFileSync).toHaveBeenCalled();
+        expect(vi.mocked(kernelCall).mock.calls.some(([tool]) => tool === 'setup.materializeSetup')).toBe(true);
+        expect(capturedReport()?.filesSkipped?.some((f) => f.reason === 'preview-only (materialize: observe)')).toBeFalsy();
+    });
+    it('--surfaces is an intersection with manifest.surfaces, not a superset', async () => {
+        vi.mocked(readManifestStatus).mockReturnValue({
+            mode: 'project',
+            surfaces: ['.cursor'],
+            lock: {},
+            parseStatus: 'ok',
+            manifest: null,
+        });
+        vi.mocked(shouldEmitToTarget).mockImplementation((_entry, target) => target === 'cursor');
+        vi.mocked(generateCursorSkill).mockImplementation((skill) => skill.body);
+        vi.mocked(kernelCall).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 [{
+                        entryId: 'SETUP-SKILL-INTERSECTION',
+                        name: 'Intersection',
+                        description: 'Intersection',
+                        body: '# Intersection',
+                        triggers: [],
+                        assetKind: 'skill',
+                        semanticRefs: [],
+                        disabledByOwner: false,
+                        lastProjectedHash: null,
+                    }];
+            }
+            if (tool === 'setup.getCurrentSetupState')
+                return { effectiveMode: 'observe' };
+            if (tool === 'setup.recordTransition')
+                return { ok: true, receiptId: 'r1', deduped: false };
+            return [];
+        });
+        await runHandshake({ apply: true, surfaces: ['claude'] });
+        expect(writeFileSync).not.toHaveBeenCalledWith(expect.stringContaining('/.cursor/skills/Intersection/SKILL.md'), expect.any(String));
+    });
+    it('apply records a mode-change transition when manifest mode differs from current setup state', async () => {
+        vi.mocked(readManifestStatus).mockReturnValue({
+            mode: 'project',
+            surfaces: ['.cursor'],
+            lock: { 'SETUP-SKILL-TRANSITION': 'workspace' },
+            parseStatus: 'ok',
+            manifest: null,
+        });
+        vi.mocked(kernelCall).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 [];
+            if (tool === 'setup.getCurrentSetupState')
+                return { effectiveMode: 'observe' };
+            if (tool === 'setup.recordTransition')
+                return { ok: true, receiptId: 'r1', deduped: false };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        expect(kernelCall).toHaveBeenCalledWith('setup.recordTransition', {
+            fromMode: 'observe',
+            toMode: 'project',
+            parseStatus: 'ok',
+            surfaces: ['.cursor'],
+            lock: { 'SETUP-SKILL-TRANSITION': 'workspace' },
+        });
+    });
+    it('apply bulk-imports .productbrain authoring files with frontmatter id before DB projection', async () => {
+        vi.mocked(readManifestStatus).mockReturnValue({
+            mode: 'project',
+            surfaces: ['.cursor'],
+            lock: {},
+            parseStatus: 'ok',
+            manifest: null,
+        });
+        const skillPath = `${MOCK_CWD}/.productbrain/skills/local.md`;
+        vfs[`${MOCK_CWD}/.productbrain/skills`] = '';
+        vfs[skillPath] = [
+            '---',
+            'id: SETUP-SKILL-FRONTMATTER',
+            'name: Local Skill',
+            'description: Local description',
+            'triggers:',
+            '  - local',
+            'semanticRefs:',
+            '  - entry:WP-423',
+            '---',
+            '# Local Skill',
+            '',
+            'Body.',
+        ].join('\n');
+        vi.mocked(readdirSync).mockImplementation((path) => {
+            if (String(path).endsWith('/.productbrain/skills'))
+                return ['local.md'];
+            return [];
+        });
+        vi.mocked(kernelCall).mockImplementation(async (tool) => {
+            if (tool === 'chain.workspaceReadiness')
+                return null;
+            if (tool === 'chain.getOrientView')
+                return null;
+            if (tool === 'chain.searchEntries')
+                return [];
+            // WP-428 S2 (Critical #1): CLI now calls ingestSetupAssetWithBody per-asset.
+            if (tool === 'setup.ingestSetupAssetWithBody')
+                return { action: 'created', entryId: 'SETUP-SKILL-FRONTMATTER' };
+            if (tool === 'setup.listAssetsForUser')
+                return [];
+            if (tool === 'setup.getCurrentSetupState')
+                return { effectiveMode: 'project' };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        // WP-428 S2: CLI now calls ingestSetupAssetWithBody per-asset (not ingestSetupAssetsBatch).
+        expect(kernelCall).toHaveBeenCalledWith('setup.ingestSetupAssetWithBody', expect.objectContaining({
+            entryId: 'SETUP-SKILL-LOCAL',
+            frontmatterId: 'SETUP-SKILL-FRONTMATTER',
+            name: 'Local Skill',
+            description: 'Local description',
+            assetKind: 'skill',
+            triggers: ['local'],
+            semanticRefs: ['entry:WP-423'],
+        }));
+    });
     it('preview mode reports unchanged for files with identical content', async () => {
         const agentsPath = `${MOCK_CWD}/AGENTS.md`;
         vfs[agentsPath] = `<!-- ${MOCK_MARKER} -->\nagents content`;
@@ -145,14 +339,66 @@ describe('runHandshake — preview/apply/dryRun invariants (WP-332 S1)', () => {
         const entry = report?.previewPlan?.find((e) => e.path.includes('AGENTS.md') && e.status === 'unchanged');
         expect(entry).toBeDefined();
     });
-    it('forked adapter (file exists without MARKER) = forked in previewPlan, no write', async () => {
+    it('user-owned adapter (file exists without MARKER) = would-augment in previewPlan, no write (TEN-2155)', async () => {
+        // TEN-2155: user-owned CLAUDE.md/AGENTS.md (no MARKER) are now AUGMENTED with a PB
+        // region rather than left fully untouched. In preview mode this shows as 'would-augment'
+        // in the previewPlan. No bytes are written to disk in preview mode.
         const agentsPath = `${MOCK_CWD}/AGENTS.md`;
         vfs[agentsPath] = '# Custom AGENTS\nNo auto-generated marker here.';
         await runHandshake({});
         expect(writeFileSync).not.toHaveBeenCalled();
         const report = capturedReport();
-        const entry = report?.previewPlan?.find((e) => e.path.includes('AGENTS.md') && e.status === 'forked');
+        const entry = report?.previewPlan?.find((e) => e.path.includes('AGENTS.md') && e.status === 'would-augment');
         expect(entry).toBeDefined();
+        // Never labelled as a "forked" conflict the user must --force away.
+        const forkedEntry = report?.previewPlan?.find((e) => e.status === 'forked');
+        expect(forkedEntry).toBeUndefined();
+    });
+    it('apply: user-owned files (no MARKER) are augmented with a PB region, not skipped (TEN-2155)', async () => {
+        // TEN-2155: user-owned CLAUDE.md/AGENTS.md get a pb:region spliced in — they are
+        // NOT added to userOwnedSkipped. Their original content is preserved; only the PB
+        // region block is appended. They must appear in filesWritten, not filesSkipped.
+        const claudePath = `${MOCK_CWD}/CLAUDE.md`;
+        const agentsPath = `${MOCK_CWD}/AGENTS.md`;
+        const userClaude = '# My own CLAUDE.md\nNo auto-generated marker.';
+        const userAgents = '# My own AGENTS.md\nNo auto-generated marker.';
+        vfs[claudePath] = userClaude;
+        vfs[agentsPath] = userAgents;
+        const report = await runHandshake({ apply: true });
+        // Augmented files appear in filesWritten, not userOwnedSkipped.
+        expect(report?.filesWritten).toEqual(expect.arrayContaining(['CLAUDE.md', 'AGENTS.md']));
+        expect(report?.userOwnedSkipped ?? []).not.toEqual(expect.arrayContaining(['CLAUDE.md']));
+        expect(report?.userOwnedSkipped ?? []).not.toEqual(expect.arrayContaining(['AGENTS.md']));
+        // The augmented content on disk must contain the original user content.
+        expect(vfs[claudePath]).toContain(userClaude);
+        expect(vfs[agentsPath]).toContain(userAgents);
+        // And the PB region sentinel must be present (the full sentinel includes a comment suffix).
+        expect(vfs[claudePath]).toContain('<!-- pb:region:start');
+        expect(vfs[agentsPath]).toContain('<!-- pb:region:start');
+    });
+    it('apply: user-owned files never trigger a chain.createEntry drift TEN, even with an active session + receipts (TEN-2150)', async () => {
+        vfs[`${MOCK_CWD}/CLAUDE.md`] = '# My own CLAUDE.md\nNo auto-generated marker.';
+        vfs[`${MOCK_CWD}/AGENTS.md`] = '# My own AGENTS.md\nNo auto-generated marker.';
+        // Force the EXACT conditions under which the old code logged the spurious draft
+        // TEN: an active write session + a workspace that already has setup receipts
+        // (non-first-run). hasAnyReceipt is ignored post-fix but proves this is a real
+        // RED guard against the removed forked-adapter drift-logging block.
+        vi.mocked(readSession).mockReturnValue({ sessionId: 'test-session' });
+        vi.mocked(kernelCall).mockImplementation(async (tool) => tool === 'setup.listAssetsForUser'
+            ? { activeAssets: [], dormantAssets: [], hasAnyReceipt: true }
+            : []);
+        try {
+            await runHandshake({ apply: true });
+            // The session-bound path is genuinely exercised (materializeSetup runs through it)…
+            expect(kernelCallWithSession).toHaveBeenCalled();
+            // …but NO draft TEN is ever logged about the user's own files.
+            expect(kernelCallWithSession).not.toHaveBeenCalledWith('chain.createEntry', expect.anything());
+        }
+        finally {
+            // Restore defaults — beforeEach clears call history but not implementations.
+            vi.mocked(readSession).mockReturnValue(null);
+            vi.mocked(kernelCall).mockResolvedValue([]);
+        }
     });
     it('apply mode projects DB setup assets with body-derived refs, disabled filtering, and hash trailers', async () => {
         vi.mocked(shouldEmitToTarget).mockImplementation((_entry, target) => target === 'cursor');
@@ -275,5 +521,321 @@ describe('runHandshake — preview/apply/dryRun invariants (WP-332 S1)', () => {
         await runHandshake({ apply: true, surfaces: ['cursor'] });
         expect(vi.mocked(kernelCall).mock.calls.some(([tool]) => tool === 'setup.updateLastProjectedHash')).toBe(false);
     });
+    it('writes missing caller-owned personal DB assets back to .productbrain authoring files', async () => {
+        vi.mocked(kernelCall).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: [
+                        {
+                            entryId: 'SETUP-SKILL-PERSONAL',
+                            name: 'Personal Skill',
+                            description: 'Personal authoring row.',
+                            body: '# Personal Skill\nBody.',
+                            triggers: ['personal'],
+                            assetKind: 'skill',
+                            semanticRefs: ['entry:WP-423'],
+                            disabledByOwner: false,
+                            lastProjectedHash: null,
+                            scope: 'personal',
+                        },
+                    ],
+                    dormantAssets: [],
+                    hasAnyReceipt: true,
+                };
+            }
+            if (tool === 'setup.updateLastProjectedHash')
+                return { ok: true };
+            if (tool === 'setup.materializeSetup')
+                return { ok: true, assetCount: 1, receiptWritten: true };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        const path = `${MOCK_CWD}/.productbrain/skills/Personal Skill.md`;
+        expect(vfs[path]).toContain('id: SETUP-SKILL-PERSONAL');
+        expect(vfs[path]).toContain('# Personal Skill\nBody.');
+        expect(vi.mocked(kernelCall).mock.calls.some(([tool]) => tool === 'setup.updateLastProjectedHash')).toBe(true);
+    });
+    it('writes newer DB edits over a tracked authoring file unchanged from baseline', async () => {
+        const baselineHash = setupAuthoringTestHash({
+            entryId: 'SETUP-SKILL-DB-WINS',
+            name: 'DB Wins',
+            description: 'DB should win.',
+            assetKind: 'skill',
+            body: '# Original',
+        });
+        vfs[`${MOCK_CWD}/.productbrain/skills`] = '';
+        vfs[`${MOCK_CWD}/.productbrain/skills/DB Wins.md`] = [
+            '---',
+            'id: SETUP-SKILL-DB-WINS',
+            'name: "DB Wins"',
+            'description: "DB should win."',
+            'assetKind: skill',
+            '---',
+            '# Original',
+            '',
+        ].join('\n');
+        vfs[`${MOCK_CWD}/.productbrain/.authoring-sync.json`] = JSON.stringify({
+            version: 1,
+            assets: {
+                'SETUP-SKILL-DB-WINS': {
+                    path: '.productbrain/skills/DB Wins.md',
+                    hash: baselineHash,
+                },
+            },
+        });
+        vi.mocked(readdirSync).mockImplementation((path) => {
+            if (String(path).endsWith('/.productbrain/skills'))
+                return ['DB Wins.md'];
+            return [];
+        });
+        vi.mocked(kernelCall).mockImplementation(async (tool) => {
+            if (tool === 'chain.workspaceReadiness')
+                return null;
+            if (tool === 'chain.getOrientView')
+                return null;
+            if (tool === 'chain.searchEntries')
+                return [];
+            // WP-428 S2 (Critical #1): CLI now calls ingestSetupAssetWithBody per-asset.
+            if (tool === 'setup.ingestSetupAssetWithBody') {
+                return { action: 'unchanged', entryId: 'SETUP-SKILL-DB-WINS' };
+            }
+            if (tool === 'setup.listAssetsForUser') {
+                return {
+                    activeAssets: [
+                        {
+                            entryId: 'SETUP-SKILL-DB-WINS',
+                            name: 'DB Wins',
+                            description: 'DB should win.',
+                            body: '# DB edit',
+                            triggers: [],
+                            assetKind: 'skill',
+                            semanticRefs: [],
+                            disabledByOwner: false,
+                            lastProjectedHash: baselineHash,
+                            scope: 'personal',
+                        },
+                    ],
+                    dormantAssets: [],
+                    hasAnyReceipt: true,
+                };
+            }
+            if (tool === 'setup.updateLastProjectedHash')
+                return { ok: true };
+            if (tool === 'setup.materializeSetup')
+                return { ok: true, assetCount: 1, receiptWritten: true };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        expect(vfs[`${MOCK_CWD}/.productbrain/skills/DB Wins.md`]).toContain('# DB edit');
+        expect(vi.mocked(kernelCall).mock.calls.some(([tool]) => tool === 'setup.updateLastProjectedHash')).toBe(true);
+    });
+    it('marks personal DB assets dormant when their tracked authoring file is deleted', async () => {
+        const syncedHash = setupAuthoringTestHash({
+            entryId: 'SETUP-SKILL-DELETED',
+            name: 'Deleted Skill',
+            description: 'Deleted authoring row.',
+            assetKind: 'skill',
+            body: '# Deleted Skill\nBody.',
+        });
+        vfs[`${MOCK_CWD}/.productbrain/.authoring-sync.json`] = JSON.stringify({
+            version: 1,
+            assets: {
+                'SETUP-SKILL-DELETED': {
+                    path: '.productbrain/skills/Deleted Skill.md',
+                    hash: syncedHash,
+                },
+            },
+        });
+        vi.mocked(kernelCall).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: [
+                        {
+                            entryId: 'SETUP-SKILL-DELETED',
+                            name: 'Deleted Skill',
+                            description: 'Deleted authoring row.',
+                            body: '# Deleted Skill\nBody.',
+                            triggers: [],
+                            assetKind: 'skill',
+                            semanticRefs: [],
+                            disabledByOwner: false,
+                            lastProjectedHash: syncedHash,
+                            scope: 'personal',
+                        },
+                    ],
+                    dormantAssets: [],
+                    hasAnyReceipt: true,
+                };
+            }
+            if (tool === 'setup.markPersonalSetupAssetDormantFromSync')
+                return { action: 'dormant', entryId: 'SETUP-SKILL-DELETED' };
+            if (tool === 'setup.materializeSetup')
+                return { ok: true, assetCount: 0, receiptWritten: true };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        expect(vi.mocked(kernelCall).mock.calls).toContainEqual([
+            'setup.markPersonalSetupAssetDormantFromSync',
+            { entryId: 'SETUP-SKILL-DELETED', expectedLastProjectedHash: syncedHash },
+        ]);
+    });
+    it('does not mark a stale tracked deletion dormant when the DB baseline changed', async () => {
+        vfs[`${MOCK_CWD}/.productbrain/.authoring-sync.json`] = JSON.stringify({
+            version: 1,
+            assets: {
+                'SETUP-SKILL-STALE': {
+                    path: '.productbrain/skills/Stale Skill.md',
+                    hash: 'sha256:old-baseline',
+                },
+            },
+        });
+        vi.mocked(kernelCall).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: [
+                        {
+                            entryId: 'SETUP-SKILL-STALE',
+                            name: 'Stale Skill',
+                            description: 'DB changed after local sync.',
+                            body: '# Stale Skill\nUpdated DB body.',
+                            triggers: [],
+                            assetKind: 'skill',
+                            semanticRefs: [],
+                            disabledByOwner: false,
+                            lastProjectedHash: 'sha256:new-baseline',
+                            scope: 'personal',
+                        },
+                    ],
+                    dormantAssets: [],
+                    hasAnyReceipt: true,
+                };
+            }
+            if (tool === 'setup.updateLastProjectedHash')
+                return { ok: true };
+            if (tool === 'setup.materializeSetup')
+                return { ok: true, assetCount: 1, receiptWritten: true };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        expect(vi.mocked(kernelCall).mock.calls.some(([tool]) => tool === 'setup.markPersonalSetupAssetDormantFromSync')).toBe(false);
+        expect(vfs[`${MOCK_CWD}/.productbrain/skills/Stale Skill.md`]).toContain('Updated DB body.');
+    });
+    it('does not write a stale snapshot back when dormant sync returns a server-side conflict', async () => {
+        const listedHash = setupAuthoringTestHash({
+            entryId: 'SETUP-SKILL-RACE',
+            name: 'Race Skill',
+            description: 'Race during sync.',
+            assetKind: 'skill',
+            body: '# Race Skill\nDB body.',
+        });
+        vfs[`${MOCK_CWD}/.productbrain/.authoring-sync.json`] = JSON.stringify({
+            version: 1,
+            assets: {
+                'SETUP-SKILL-RACE': {
+                    path: '.productbrain/skills/Race Skill.md',
+                    hash: listedHash,
+                },
+            },
+        });
+        vi.mocked(kernelCall).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: [
+                        {
+                            entryId: 'SETUP-SKILL-RACE',
+                            name: 'Race Skill',
+                            description: 'Race during sync.',
+                            body: '# Race Skill\nDB body.',
+                            triggers: [],
+                            assetKind: 'skill',
+                            semanticRefs: [],
+                            disabledByOwner: false,
+                            lastProjectedHash: listedHash,
+                            scope: 'personal',
+                        },
+                    ],
+                    dormantAssets: [],
+                    hasAnyReceipt: true,
+                };
+            }
+            if (tool === 'setup.markPersonalSetupAssetDormantFromSync')
+                return { action: 'conflict', entryId: 'SETUP-SKILL-RACE' };
+            if (tool === 'setup.updateLastProjectedHash')
+                return { ok: true };
+            if (tool === 'setup.materializeSetup')
+                return { ok: true, assetCount: 1, receiptWritten: true };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        expect(vi.mocked(kernelCall).mock.calls).toContainEqual([
+            'setup.markPersonalSetupAssetDormantFromSync',
+            { entryId: 'SETUP-SKILL-RACE', expectedLastProjectedHash: listedHash },
+        ]);
+        expect(vfs[`${MOCK_CWD}/.productbrain/skills/Race Skill.md`]).toBeUndefined();
+        expect(vi.mocked(kernelCall).mock.calls.some(([tool, args]) => tool === 'setup.updateLastProjectedHash' &&
+            args?.entryId === 'SETUP-SKILL-RACE')).toBe(false);
+    });
+    it('does not mark a missing personal authoring file dormant on a fresh clone without local tracking state', async () => {
+        vi.mocked(kernelCall).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: [
+                        {
+                            entryId: 'SETUP-SKILL-FRESH',
+                            name: 'Fresh Skill',
+                            description: 'Fresh clone row.',
+                            body: '# Fresh Skill\nBody.',
+                            triggers: [],
+                            assetKind: 'skill',
+                            semanticRefs: [],
+                            disabledByOwner: false,
+                            lastProjectedHash: 'sha256:previous',
+                            scope: 'personal',
+                        },
+                    ],
+                    dormantAssets: [],
+                    hasAnyReceipt: true,
+                };
+            }
+            if (tool === 'setup.updateLastProjectedHash')
+                return { ok: true };
+            if (tool === 'setup.materializeSetup')
+                return { ok: true, assetCount: 1, receiptWritten: true };
+            return [];
+        });
+        await runHandshake({ apply: true });
+        expect(vi.mocked(kernelCall).mock.calls.some(([tool]) => tool === 'setup.markPersonalSetupAssetDormantFromSync')).toBe(false);
+        expect(vfs[`${MOCK_CWD}/.productbrain/skills/Fresh Skill.md`]).toContain('id: SETUP-SKILL-FRESH');
+    });
 });
 //# sourceMappingURL=handshake-preview.test.js.map