feat: strengthen install lifecycle and target adapters (#512)

* fix: strengthen install lifecycle adapters * fix: restore template content on uninstall
2026-04-01 22:53:27 +08:00 · 2026-03-15 21:47:31 -07:00
parent 1e0238de96
commit 131f977841
11 changed files with 1987 additions and 125 deletions
--- a/tests/lib/install-lifecycle.test.js
+++ b/tests/lib/install-lifecycle.test.js
@@ -10,6 +10,8 @@ const path = require('path');
 const {
  buildDoctorReport,
  discoverInstalledStates,
+  repairInstalledStates,
+  uninstallInstalledStates,
 } = require('../../scripts/lib/install-lifecycle');
 const {
  createInstallState,
@@ -350,6 +352,385 @@ function runTests() {
    }
  })) passed++; else failed++;

+  if (test('repair restores render-template outputs from recorded rendered content', () => {
+    const homeDir = createTempDir('install-lifecycle-home-');
+    const projectRoot = createTempDir('install-lifecycle-project-');
+
+    try {
+      const targetRoot = path.join(homeDir, '.claude');
+      const statePath = path.join(targetRoot, 'ecc', 'install-state.json');
+      const destinationPath = path.join(targetRoot, 'plugin.json');
+      fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+      fs.writeFileSync(destinationPath, '{"drifted":true}\n');
+
+      writeState(statePath, {
+        adapter: { id: 'claude-home', target: 'claude', kind: 'home' },
+        targetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: [],
+          legacyLanguages: ['typescript'],
+          legacyMode: true,
+        },
+        resolution: {
+          selectedModules: ['legacy-claude-rules'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'render-template',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.claude-plugin/plugin.json.template',
+            destinationPath,
+            strategy: 'render-template',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            renderedContent: '{"ok":true}\n',
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const result = repairInstalledStates({
+        repoRoot: REPO_ROOT,
+        homeDir,
+        projectRoot,
+        targets: ['claude'],
+      });
+
+      assert.strictEqual(result.results[0].status, 'repaired');
+      assert.strictEqual(fs.readFileSync(destinationPath, 'utf8'), '{"ok":true}\n');
+    } finally {
+      cleanup(homeDir);
+      cleanup(projectRoot);
+    }
+  })) passed++; else failed++;
+
+  if (test('repair reapplies merge-json operations without clobbering unrelated keys', () => {
+    const homeDir = createTempDir('install-lifecycle-home-');
+    const projectRoot = createTempDir('install-lifecycle-project-');
+
+    try {
+      const targetRoot = path.join(projectRoot, '.cursor');
+      const statePath = path.join(targetRoot, 'ecc-install-state.json');
+      const destinationPath = path.join(targetRoot, 'hooks.json');
+      fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+      fs.writeFileSync(destinationPath, JSON.stringify({
+        existing: true,
+        nested: {
+          enabled: false,
+        },
+      }, null, 2));
+
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: [],
+          legacyLanguages: ['typescript'],
+          legacyMode: true,
+        },
+        resolution: {
+          selectedModules: ['legacy-cursor-install'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'merge-json',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/hooks.json',
+            destinationPath,
+            strategy: 'merge-json',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            mergePayload: {
+              nested: {
+                enabled: true,
+              },
+              managed: 'yes',
+            },
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const result = repairInstalledStates({
+        repoRoot: REPO_ROOT,
+        homeDir,
+        projectRoot,
+        targets: ['cursor'],
+      });
+
+      assert.strictEqual(result.results[0].status, 'repaired');
+      assert.deepStrictEqual(JSON.parse(fs.readFileSync(destinationPath, 'utf8')), {
+        existing: true,
+        nested: {
+          enabled: true,
+        },
+        managed: 'yes',
+      });
+    } finally {
+      cleanup(homeDir);
+      cleanup(projectRoot);
+    }
+  })) passed++; else failed++;
+
+  if (test('repair re-applies managed remove operations when files reappear', () => {
+    const homeDir = createTempDir('install-lifecycle-home-');
+    const projectRoot = createTempDir('install-lifecycle-project-');
+
+    try {
+      const targetRoot = path.join(projectRoot, '.cursor');
+      const statePath = path.join(targetRoot, 'ecc-install-state.json');
+      const destinationPath = path.join(targetRoot, 'legacy-note.txt');
+      fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+      fs.writeFileSync(destinationPath, 'stale');
+
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: [],
+          legacyLanguages: ['typescript'],
+          legacyMode: true,
+        },
+        resolution: {
+          selectedModules: ['legacy-cursor-install'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'remove',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/legacy-note.txt',
+            destinationPath,
+            strategy: 'remove',
+            ownership: 'managed',
+            scaffoldOnly: false,
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const result = repairInstalledStates({
+        repoRoot: REPO_ROOT,
+        homeDir,
+        projectRoot,
+        targets: ['cursor'],
+      });
+
+      assert.strictEqual(result.results[0].status, 'repaired');
+      assert.ok(!fs.existsSync(destinationPath));
+    } finally {
+      cleanup(homeDir);
+      cleanup(projectRoot);
+    }
+  })) passed++; else failed++;
+
+  if (test('uninstall restores JSON merged files from recorded previous content', () => {
+    const homeDir = createTempDir('install-lifecycle-home-');
+    const projectRoot = createTempDir('install-lifecycle-project-');
+
+    try {
+      const targetRoot = path.join(projectRoot, '.cursor');
+      const statePath = path.join(targetRoot, 'ecc-install-state.json');
+      const destinationPath = path.join(targetRoot, 'hooks.json');
+      fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+      fs.writeFileSync(destinationPath, JSON.stringify({
+        existing: true,
+        managed: true,
+      }, null, 2));
+
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: [],
+          legacyLanguages: ['typescript'],
+          legacyMode: true,
+        },
+        resolution: {
+          selectedModules: ['legacy-cursor-install'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'merge-json',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/hooks.json',
+            destinationPath,
+            strategy: 'merge-json',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            mergePayload: {
+              managed: true,
+            },
+            previousContent: JSON.stringify({
+              existing: true,
+            }, null, 2),
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const result = uninstallInstalledStates({
+        homeDir,
+        projectRoot,
+        targets: ['cursor'],
+      });
+
+      assert.strictEqual(result.results[0].status, 'uninstalled');
+      assert.deepStrictEqual(JSON.parse(fs.readFileSync(destinationPath, 'utf8')), {
+        existing: true,
+      });
+      assert.ok(!fs.existsSync(statePath));
+    } finally {
+      cleanup(homeDir);
+      cleanup(projectRoot);
+    }
+  })) passed++; else failed++;
+
+  if (test('uninstall restores rendered template files from recorded previous content', () => {
+    const tempDir = createTempDir('install-lifecycle-');
+
+    try {
+      const targetRoot = path.join(tempDir, '.claude');
+      const statePath = path.join(targetRoot, 'ecc', 'install-state.json');
+      const destinationPath = path.join(targetRoot, 'plugin.json');
+      fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+      fs.writeFileSync(destinationPath, '{"generated":true}\n');
+
+      writeInstallState(statePath, createInstallState({
+        adapter: { id: 'claude-home', target: 'claude', kind: 'home' },
+        targetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: 'core',
+          modules: ['platform-configs'],
+          includeComponents: [],
+          excludeComponents: [],
+          legacyLanguages: [],
+          legacyMode: false,
+        },
+        resolution: {
+          selectedModules: ['platform-configs'],
+          skippedModules: [],
+        },
+        source: {
+          repoVersion: '1.8.0',
+          repoCommit: 'abc123',
+          manifestVersion: 1,
+        },
+        operations: [
+          {
+            kind: 'render-template',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.claude/plugin.json.template',
+            destinationPath,
+            strategy: 'render-template',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            renderedContent: '{"generated":true}\n',
+            previousContent: '{"existing":true}\n',
+          },
+        ],
+      }));
+
+      const result = uninstallInstalledStates({
+        homeDir: tempDir,
+        projectRoot: tempDir,
+        targets: ['claude'],
+      });
+
+      assert.strictEqual(result.summary.uninstalledCount, 1);
+      assert.strictEqual(fs.readFileSync(destinationPath, 'utf8'), '{"existing":true}\n');
+      assert.ok(!fs.existsSync(statePath));
+    } finally {
+      cleanup(tempDir);
+    }
+  })) passed++; else failed++;
+
+  if (test('uninstall restores files removed during install when previous content is recorded', () => {
+    const homeDir = createTempDir('install-lifecycle-home-');
+    const projectRoot = createTempDir('install-lifecycle-project-');
+
+    try {
+      const targetRoot = path.join(projectRoot, '.cursor');
+      const statePath = path.join(targetRoot, 'ecc-install-state.json');
+      const destinationPath = path.join(targetRoot, 'legacy-note.txt');
+      fs.mkdirSync(targetRoot, { recursive: true });
+
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: [],
+          legacyLanguages: ['typescript'],
+          legacyMode: true,
+        },
+        resolution: {
+          selectedModules: ['legacy-cursor-install'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'remove',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/legacy-note.txt',
+            destinationPath,
+            strategy: 'remove',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            previousContent: 'restore me\n',
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const result = uninstallInstalledStates({
+        homeDir,
+        projectRoot,
+        targets: ['cursor'],
+      });
+
+      assert.strictEqual(result.results[0].status, 'uninstalled');
+      assert.strictEqual(fs.readFileSync(destinationPath, 'utf8'), 'restore me\n');
+      assert.ok(!fs.existsSync(statePath));
+    } finally {
+      cleanup(homeDir);
+      cleanup(projectRoot);
+    }
+  })) passed++; else failed++;
+
  console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
  process.exit(failed > 0 ? 1 : 0);
 }
--- a/tests/lib/install-state.test.js
+++ b/tests/lib/install-state.test.js
@@ -117,6 +117,56 @@ function runTests() {
    }
  })) passed++; else failed++;

+  if (test('deep-clones nested operation metadata for lifecycle-managed operations', () => {
+    const operation = {
+      kind: 'merge-json',
+      moduleId: 'platform-configs',
+      sourceRelativePath: '.cursor/hooks.json',
+      destinationPath: '/repo/.cursor/hooks.json',
+      strategy: 'merge-json',
+      ownership: 'managed',
+      scaffoldOnly: false,
+      mergePayload: {
+        nested: {
+          enabled: true,
+        },
+      },
+      previousValue: {
+        nested: {
+          enabled: false,
+        },
+      },
+    };
+
+    const state = createInstallState({
+      adapter: { id: 'cursor-project' },
+      targetRoot: '/repo/.cursor',
+      installStatePath: '/repo/.cursor/ecc-install-state.json',
+      request: {
+        profile: null,
+        modules: ['platform-configs'],
+        legacyLanguages: [],
+        legacyMode: false,
+      },
+      resolution: {
+        selectedModules: ['platform-configs'],
+        skippedModules: [],
+      },
+      operations: [operation],
+      source: {
+        repoVersion: '1.9.0',
+        repoCommit: 'abc123',
+        manifestVersion: 1,
+      },
+    });
+
+    operation.mergePayload.nested.enabled = false;
+    operation.previousValue.nested.enabled = true;
+
+    assert.strictEqual(state.operations[0].mergePayload.nested.enabled, true);
+    assert.strictEqual(state.operations[0].previousValue.nested.enabled, false);
+  })) passed++; else failed++;
+
  if (test('rejects invalid install-state payloads on read', () => {
    const testDir = createTestDir();
    const statePath = path.join(testDir, 'ecc-install-state.json');
@@ -132,6 +182,48 @@ function runTests() {
    }
  })) passed++; else failed++;

+  if (test('rejects unexpected properties and missing required request fields', () => {
+    const testDir = createTestDir();
+    const statePath = path.join(testDir, 'ecc-install-state.json');
+
+    try {
+      fs.writeFileSync(statePath, JSON.stringify({
+        schemaVersion: 'ecc.install.v1',
+        installedAt: '2026-03-13T00:00:00Z',
+        unexpected: true,
+        target: {
+          id: 'cursor-project',
+          root: '/repo/.cursor',
+          installStatePath: '/repo/.cursor/ecc-install-state.json',
+        },
+        request: {
+          modules: [],
+          includeComponents: [],
+          excludeComponents: [],
+          legacyLanguages: [],
+          legacyMode: false,
+        },
+        resolution: {
+          selectedModules: [],
+          skippedModules: [],
+        },
+        source: {
+          repoVersion: '1.9.0',
+          repoCommit: 'abc123',
+          manifestVersion: 1,
+        },
+        operations: [],
+      }, null, 2));
+
+      assert.throws(
+        () => readInstallState(statePath),
+        /Invalid install-state/
+      );
+    } finally {
+      cleanupTestDir(testDir);
+    }
+  })) passed++; else failed++;
+
  console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
  process.exit(failed > 0 ? 1 : 0);
 }
--- a/tests/lib/install-targets.test.js
+++ b/tests/lib/install-targets.test.js
@@ -60,7 +60,7 @@ function runTests() {
  })) passed++; else failed++;

  if (test('plans scaffold operations and flattens native target roots', () => {
-    const repoRoot = '/repo/ecc';
+    const repoRoot = path.join(__dirname, '..', '..');
    const projectRoot = '/workspace/app';
    const modules = [
      {
@@ -85,15 +85,124 @@ function runTests() {
    assert.strictEqual(plan.installStatePath, path.join(projectRoot, '.cursor', 'ecc-install-state.json'));

    const flattened = plan.operations.find(operation => operation.sourceRelativePath === '.cursor');
-    const preserved = plan.operations.find(operation => operation.sourceRelativePath === 'rules');
+    const preserved = plan.operations.find(operation => (
+      operation.sourceRelativePath === path.join('rules', 'common', 'coding-style.md')
+    ));

    assert.ok(flattened, 'Should include .cursor scaffold operation');
    assert.strictEqual(flattened.strategy, 'sync-root-children');
    assert.strictEqual(flattened.destinationPath, path.join(projectRoot, '.cursor'));

-    assert.ok(preserved, 'Should include rules scaffold operation');
-    assert.strictEqual(preserved.strategy, 'preserve-relative-path');
-    assert.strictEqual(preserved.destinationPath, path.join(projectRoot, '.cursor', 'rules'));
+    assert.ok(preserved, 'Should include flattened rules scaffold operations');
+    assert.strictEqual(preserved.strategy, 'flatten-copy');
+    assert.strictEqual(
+      preserved.destinationPath,
+      path.join(projectRoot, '.cursor', 'rules', 'common-coding-style.md')
+    );
+  })) passed++; else failed++;
+
+  if (test('plans cursor rules with flat namespaced filenames to avoid rule collisions', () => {
+    const repoRoot = path.join(__dirname, '..', '..');
+    const projectRoot = '/workspace/app';
+
+    const plan = planInstallTargetScaffold({
+      target: 'cursor',
+      repoRoot,
+      projectRoot,
+      modules: [
+        {
+          id: 'rules-core',
+          paths: ['rules'],
+        },
+      ],
+    });
+
+    assert.ok(
+      plan.operations.some(operation => (
+        operation.sourceRelativePath === path.join('rules', 'common', 'coding-style.md')
+        && operation.destinationPath === path.join(projectRoot, '.cursor', 'rules', 'common-coding-style.md')
+      )),
+      'Should flatten common rules into namespaced files'
+    );
+    assert.ok(
+      plan.operations.some(operation => (
+        operation.sourceRelativePath === path.join('rules', 'typescript', 'testing.md')
+        && operation.destinationPath === path.join(projectRoot, '.cursor', 'rules', 'typescript-testing.md')
+      )),
+      'Should flatten language rules into namespaced files'
+    );
+    assert.ok(
+      !plan.operations.some(operation => (
+        operation.destinationPath === path.join(projectRoot, '.cursor', 'rules', 'common', 'coding-style.md')
+      )),
+      'Should not preserve nested rule directories for cursor installs'
+    );
+  })) passed++; else failed++;
+
+  if (test('plans antigravity remaps for workflows, skills, and flat rules', () => {
+    const repoRoot = path.join(__dirname, '..', '..');
+    const projectRoot = '/workspace/app';
+
+    const plan = planInstallTargetScaffold({
+      target: 'antigravity',
+      repoRoot,
+      projectRoot,
+      modules: [
+        {
+          id: 'commands-core',
+          paths: ['commands'],
+        },
+        {
+          id: 'agents-core',
+          paths: ['agents'],
+        },
+        {
+          id: 'rules-core',
+          paths: ['rules'],
+        },
+      ],
+    });
+
+    assert.ok(
+      plan.operations.some(operation => (
+        operation.sourceRelativePath === 'commands'
+        && operation.destinationPath === path.join(projectRoot, '.agent', 'workflows')
+      )),
+      'Should remap commands into workflows'
+    );
+    assert.ok(
+      plan.operations.some(operation => (
+        operation.sourceRelativePath === 'agents'
+        && operation.destinationPath === path.join(projectRoot, '.agent', 'skills')
+      )),
+      'Should remap agents into skills'
+    );
+    assert.ok(
+      plan.operations.some(operation => (
+        operation.sourceRelativePath === path.join('rules', 'common', 'coding-style.md')
+        && operation.destinationPath === path.join(projectRoot, '.agent', 'rules', 'common-coding-style.md')
+      )),
+      'Should flatten common rules for antigravity'
+    );
+  })) passed++; else failed++;
+
+  if (test('exposes validate and planOperations on adapters', () => {
+    const claudeAdapter = getInstallTargetAdapter('claude');
+    const cursorAdapter = getInstallTargetAdapter('cursor');
+
+    assert.strictEqual(typeof claudeAdapter.planOperations, 'function');
+    assert.strictEqual(typeof claudeAdapter.validate, 'function');
+    assert.deepStrictEqual(
+      claudeAdapter.validate({ homeDir: '/Users/example', repoRoot: '/repo/ecc' }),
+      []
+    );
+
+    assert.strictEqual(typeof cursorAdapter.planOperations, 'function');
+    assert.strictEqual(typeof cursorAdapter.validate, 'function');
+    assert.deepStrictEqual(
+      cursorAdapter.validate({ projectRoot: '/workspace/app', repoRoot: '/repo/ecc' }),
+      []
+    );
  })) passed++; else failed++;

  if (test('throws on unknown target adapter', () => {
--- a/tests/scripts/repair.test.js
+++ b/tests/scripts/repair.test.js
@@ -12,6 +12,16 @@ const INSTALL_SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'install-appl
 const DOCTOR_SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'doctor.js');
 const REPAIR_SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'repair.js');
 const REPO_ROOT = path.join(__dirname, '..', '..');
+const CURRENT_PACKAGE_VERSION = JSON.parse(
+  fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8')
+).version;
+const CURRENT_MANIFEST_VERSION = JSON.parse(
+  fs.readFileSync(path.join(REPO_ROOT, 'manifests', 'install-modules.json'), 'utf8')
+).version;
+const {
+  createInstallState,
+  writeInstallState,
+} = require('../../scripts/lib/install-state');

 function createTempDir(prefix) {
  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
@@ -21,6 +31,12 @@ function cleanup(dirPath) {
  fs.rmSync(dirPath, { recursive: true, force: true });
 }

+function writeState(filePath, options) {
+  const state = createInstallState(options);
+  writeInstallState(filePath, state);
+  return state;
+}
+
 function runNode(scriptPath, args = [], options = {}) {
  const env = {
    ...process.env,
@@ -64,26 +80,25 @@ function runTests() {
  let passed = 0;
  let failed = 0;

-  if (test('repairs drifted managed files and refreshes install-state', () => {
+  if (test('repairs drifted files from a real install-apply state', () => {
    const homeDir = createTempDir('repair-home-');
    const projectRoot = createTempDir('repair-project-');

    try {
-      const installResult = runNode(INSTALL_SCRIPT, ['--target', 'cursor', '--modules', 'platform-configs'], {
+      const installResult = runNode(INSTALL_SCRIPT, ['--target', 'cursor', 'typescript'], {
        cwd: projectRoot,
        homeDir,
      });
      assert.strictEqual(installResult.code, 0, installResult.stderr);

-      const cursorRoot = path.join(projectRoot, '.cursor');
-      const managedPath = path.join(cursorRoot, 'hooks.json');
-      const statePath = path.join(cursorRoot, 'ecc-install-state.json');
-      const managedRealPath = fs.realpathSync(cursorRoot);
-      const expectedManagedPath = path.join(managedRealPath, 'hooks.json');
-      const expectedContent = fs.readFileSync(path.join(REPO_ROOT, '.cursor', 'hooks.json'), 'utf8');
-      const installedAtBefore = JSON.parse(fs.readFileSync(statePath, 'utf8')).installedAt;
-
-      fs.writeFileSync(managedPath, '{"drifted":true}\n');
+      const normalizedProjectRoot = fs.realpathSync(projectRoot);
+      const managedPath = path.join(normalizedProjectRoot, '.cursor', 'hooks', 'session-start.js');
+      const statePath = path.join(normalizedProjectRoot, '.cursor', 'ecc-install-state.json');
+      const expectedContent = fs.readFileSync(
+        path.join(REPO_ROOT, '.cursor', 'hooks', 'session-start.js'),
+        'utf8'
+      );
+      fs.writeFileSync(managedPath, '// drifted\n');

      const doctorBefore = runNode(DOCTOR_SCRIPT, ['--target', 'cursor', '--json'], {
        cwd: projectRoot,
@@ -100,8 +115,118 @@ function runTests() {

      const parsed = JSON.parse(repairResult.stdout);
      assert.strictEqual(parsed.results[0].status, 'repaired');
-      assert.ok(parsed.results[0].repairedPaths.includes(expectedManagedPath));
+      assert.ok(parsed.results[0].repairedPaths.includes(managedPath));
      assert.strictEqual(fs.readFileSync(managedPath, 'utf8'), expectedContent);
+      assert.ok(fs.existsSync(statePath));
+    } finally {
+      cleanup(homeDir);
+      cleanup(projectRoot);
+    }
+  })) passed++; else failed++;
+
+  if (test('repairs drifted non-copy managed operations and refreshes install-state', () => {
+    const homeDir = createTempDir('repair-home-');
+    const projectRoot = createTempDir('repair-project-');
+
+    try {
+      const targetRoot = path.join(projectRoot, '.cursor');
+      fs.mkdirSync(targetRoot, { recursive: true });
+      const normalizedTargetRoot = fs.realpathSync(targetRoot);
+      const statePath = path.join(normalizedTargetRoot, 'ecc-install-state.json');
+      const jsonPath = path.join(normalizedTargetRoot, 'hooks.json');
+      const renderedPath = path.join(normalizedTargetRoot, 'generated.md');
+      const removedPath = path.join(normalizedTargetRoot, 'legacy-note.txt');
+      fs.writeFileSync(jsonPath, JSON.stringify({ existing: true, managed: false }, null, 2));
+      fs.writeFileSync(renderedPath, '# drifted\n');
+      fs.writeFileSync(removedPath, 'stale\n');
+
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot: normalizedTargetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: ['platform-configs'],
+          includeComponents: [],
+          excludeComponents: [],
+          legacyLanguages: [],
+          legacyMode: false,
+        },
+        resolution: {
+          selectedModules: ['platform-configs'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'merge-json',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/hooks.json',
+            destinationPath: jsonPath,
+            strategy: 'merge-json',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            mergePayload: {
+              managed: true,
+              nested: {
+                enabled: true,
+              },
+            },
+          },
+          {
+            kind: 'render-template',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/generated.md.template',
+            destinationPath: renderedPath,
+            strategy: 'render-template',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            renderedContent: '# generated\n',
+          },
+          {
+            kind: 'remove',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/legacy-note.txt',
+            destinationPath: removedPath,
+            strategy: 'remove',
+            ownership: 'managed',
+            scaffoldOnly: false,
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const doctorBefore = runNode(DOCTOR_SCRIPT, ['--target', 'cursor', '--json'], {
+        cwd: projectRoot,
+        homeDir,
+      });
+      assert.strictEqual(doctorBefore.code, 1);
+      assert.ok(JSON.parse(doctorBefore.stdout).results[0].issues.some(issue => issue.code === 'drifted-managed-files'));
+
+      const installedAtBefore = JSON.parse(fs.readFileSync(statePath, 'utf8')).installedAt;
+      const repairResult = runNode(REPAIR_SCRIPT, ['--target', 'cursor', '--json'], {
+        cwd: projectRoot,
+        homeDir,
+      });
+      assert.strictEqual(repairResult.code, 0, repairResult.stderr);
+
+      const parsed = JSON.parse(repairResult.stdout);
+      assert.strictEqual(parsed.results[0].status, 'repaired');
+      assert.ok(parsed.results[0].repairedPaths.includes(jsonPath));
+      assert.ok(parsed.results[0].repairedPaths.includes(renderedPath));
+      assert.ok(parsed.results[0].repairedPaths.includes(removedPath));
+      assert.deepStrictEqual(JSON.parse(fs.readFileSync(jsonPath, 'utf8')), {
+        existing: true,
+        managed: true,
+        nested: {
+          enabled: true,
+        },
+      });
+      assert.strictEqual(fs.readFileSync(renderedPath, 'utf8'), '# generated\n');
+      assert.ok(!fs.existsSync(removedPath));

      const repairedState = JSON.parse(fs.readFileSync(statePath, 'utf8'));
      assert.strictEqual(repairedState.installedAt, installedAtBefore);
@@ -119,23 +244,52 @@ function runTests() {
    }
  })) passed++; else failed++;

-  if (test('supports dry-run without mutating drifted files', () => {
+  if (test('supports dry-run without mutating drifted non-copy operations', () => {
    const homeDir = createTempDir('repair-home-');
    const projectRoot = createTempDir('repair-project-');

    try {
-      const installResult = runNode(INSTALL_SCRIPT, ['--target', 'cursor', '--modules', 'platform-configs'], {
-        cwd: projectRoot,
-        homeDir,
-      });
-      assert.strictEqual(installResult.code, 0, installResult.stderr);
+      const targetRoot = path.join(projectRoot, '.cursor');
+      fs.mkdirSync(targetRoot, { recursive: true });
+      const normalizedTargetRoot = fs.realpathSync(targetRoot);
+      const statePath = path.join(normalizedTargetRoot, 'ecc-install-state.json');
+      const renderedPath = path.join(normalizedTargetRoot, 'generated.md');
+      fs.writeFileSync(renderedPath, '# drifted\n');

-      const cursorRoot = path.join(projectRoot, '.cursor');
-      const managedPath = path.join(cursorRoot, 'hooks.json');
-      const managedRealPath = fs.realpathSync(cursorRoot);
-      const expectedManagedPath = path.join(managedRealPath, 'hooks.json');
-      const driftedContent = '{"drifted":true}\n';
-      fs.writeFileSync(managedPath, driftedContent);
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot: normalizedTargetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: ['platform-configs'],
+          includeComponents: [],
+          excludeComponents: [],
+          legacyLanguages: [],
+          legacyMode: false,
+        },
+        resolution: {
+          selectedModules: ['platform-configs'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'render-template',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/generated.md.template',
+            destinationPath: renderedPath,
+            strategy: 'render-template',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            renderedContent: '# generated\n',
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });

      const repairResult = runNode(REPAIR_SCRIPT, ['--target', 'cursor', '--dry-run', '--json'], {
        cwd: projectRoot,
@@ -144,8 +298,8 @@ function runTests() {
      assert.strictEqual(repairResult.code, 0, repairResult.stderr);
      const parsed = JSON.parse(repairResult.stdout);
      assert.strictEqual(parsed.dryRun, true);
-      assert.ok(parsed.results[0].plannedRepairs.includes(expectedManagedPath));
-      assert.strictEqual(fs.readFileSync(managedPath, 'utf8'), driftedContent);
+      assert.ok(parsed.results[0].plannedRepairs.includes(renderedPath));
+      assert.strictEqual(fs.readFileSync(renderedPath, 'utf8'), '# drifted\n');
    } finally {
      cleanup(homeDir);
      cleanup(projectRoot);
--- a/tests/scripts/uninstall.test.js
+++ b/tests/scripts/uninstall.test.js
@@ -9,7 +9,18 @@ const path = require('path');
 const { execFileSync } = require('child_process');

 const INSTALL_SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');
-const UNINSTALL_SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'uninstall.js');
+const SCRIPT = path.join(__dirname, '..', '..', 'scripts', 'uninstall.js');
+const REPO_ROOT = path.join(__dirname, '..', '..');
+const CURRENT_PACKAGE_VERSION = JSON.parse(
+  fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8')
+).version;
+const CURRENT_MANIFEST_VERSION = JSON.parse(
+  fs.readFileSync(path.join(REPO_ROOT, 'manifests', 'install-modules.json'), 'utf8')
+).version;
+const {
+  createInstallState,
+  writeInstallState,
+} = require('../../scripts/lib/install-state');

 function createTempDir(prefix) {
  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
@@ -19,14 +30,20 @@ function cleanup(dirPath) {
  fs.rmSync(dirPath, { recursive: true, force: true });
 }

-function runNode(scriptPath, args = [], options = {}) {
+function writeState(filePath, options) {
+  const state = createInstallState(options);
+  writeInstallState(filePath, state);
+  return state;
+}
+
+function run(args = [], options = {}) {
  const env = {
    ...process.env,
    HOME: options.homeDir || process.env.HOME,
  };

  try {
-    const stdout = execFileSync('node', [scriptPath, ...args], {
+    const stdout = execFileSync('node', [SCRIPT, ...args], {
      cwd: options.cwd,
      env,
      encoding: 'utf8',
@@ -62,24 +79,30 @@ function runTests() {
  let passed = 0;
  let failed = 0;

-  if (test('removes managed files and keeps unrelated files', () => {
+  if (test('uninstalls files from a real install-apply state and preserves unrelated files', () => {
    const homeDir = createTempDir('uninstall-home-');
    const projectRoot = createTempDir('uninstall-project-');

    try {
-      const installResult = runNode(INSTALL_SCRIPT, ['--target', 'cursor', '--modules', 'platform-configs'], {
+      const installStdout = execFileSync('node', [INSTALL_SCRIPT, '--target', 'cursor', 'typescript'], {
        cwd: projectRoot,
-        homeDir,
+        env: {
+          ...process.env,
+          HOME: homeDir,
+        },
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000,
      });
-      assert.strictEqual(installResult.code, 0, installResult.stderr);
+      assert.ok(installStdout.includes('Done. Install-state written'));

-      const cursorRoot = path.join(projectRoot, '.cursor');
-      const managedPath = path.join(cursorRoot, 'hooks.json');
-      const statePath = path.join(cursorRoot, 'ecc-install-state.json');
-      const unrelatedPath = path.join(cursorRoot, 'custom-user-note.txt');
+      const normalizedProjectRoot = fs.realpathSync(projectRoot);
+      const managedPath = path.join(normalizedProjectRoot, '.cursor', 'hooks.json');
+      const statePath = path.join(normalizedProjectRoot, '.cursor', 'ecc-install-state.json');
+      const unrelatedPath = path.join(normalizedProjectRoot, '.cursor', 'custom-user-note.txt');
      fs.writeFileSync(unrelatedPath, 'leave me alone');

-      const uninstallResult = runNode(UNINSTALL_SCRIPT, ['--target', 'cursor'], {
+      const uninstallResult = run(['--target', 'cursor'], {
        cwd: projectRoot,
        homeDir,
      });
@@ -94,22 +117,152 @@ function runTests() {
    }
  })) passed++; else failed++;

-  if (test('supports dry-run without removing files', () => {
+  if (test('reverses non-copy operations and keeps unrelated files', () => {
    const homeDir = createTempDir('uninstall-home-');
    const projectRoot = createTempDir('uninstall-project-');

    try {
-      const installResult = runNode(INSTALL_SCRIPT, ['--target', 'cursor', '--modules', 'platform-configs'], {
+      const targetRoot = path.join(projectRoot, '.cursor');
+      fs.mkdirSync(targetRoot, { recursive: true });
+      const normalizedTargetRoot = fs.realpathSync(targetRoot);
+      const statePath = path.join(normalizedTargetRoot, 'ecc-install-state.json');
+      const copiedPath = path.join(normalizedTargetRoot, 'managed-rule.md');
+      const mergedPath = path.join(normalizedTargetRoot, 'hooks.json');
+      const removedPath = path.join(normalizedTargetRoot, 'legacy-note.txt');
+      const unrelatedPath = path.join(normalizedTargetRoot, 'custom-user-note.txt');
+      fs.writeFileSync(copiedPath, 'managed\n');
+      fs.writeFileSync(mergedPath, JSON.stringify({
+        existing: true,
+        managed: true,
+      }, null, 2));
+      fs.writeFileSync(unrelatedPath, 'leave me alone');
+
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot: normalizedTargetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: ['platform-configs'],
+          includeComponents: [],
+          excludeComponents: [],
+          legacyLanguages: [],
+          legacyMode: false,
+        },
+        resolution: {
+          selectedModules: ['platform-configs'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'copy-file',
+            moduleId: 'platform-configs',
+            sourceRelativePath: 'rules/common/coding-style.md',
+            destinationPath: copiedPath,
+            strategy: 'preserve-relative-path',
+            ownership: 'managed',
+            scaffoldOnly: false,
+          },
+          {
+            kind: 'merge-json',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/hooks.json',
+            destinationPath: mergedPath,
+            strategy: 'merge-json',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            mergePayload: {
+              managed: true,
+            },
+            previousContent: JSON.stringify({
+              existing: true,
+            }, null, 2),
+          },
+          {
+            kind: 'remove',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/legacy-note.txt',
+            destinationPath: removedPath,
+            strategy: 'remove',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            previousContent: 'restore me\n',
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const uninstallResult = run(['--target', 'cursor'], {
        cwd: projectRoot,
        homeDir,
      });
-      assert.strictEqual(installResult.code, 0, installResult.stderr);
+      assert.strictEqual(uninstallResult.code, 0, uninstallResult.stderr);
+      assert.ok(uninstallResult.stdout.includes('Uninstall summary'));
+      assert.ok(!fs.existsSync(copiedPath));
+      assert.deepStrictEqual(JSON.parse(fs.readFileSync(mergedPath, 'utf8')), {
+        existing: true,
+      });
+      assert.strictEqual(fs.readFileSync(removedPath, 'utf8'), 'restore me\n');
+      assert.ok(!fs.existsSync(statePath));
+      assert.ok(fs.existsSync(unrelatedPath));
+    } finally {
+      cleanup(homeDir);
+      cleanup(projectRoot);
+    }
+  })) passed++; else failed++;

-      const cursorRoot = path.join(projectRoot, '.cursor');
-      const managedPath = path.join(cursorRoot, 'hooks.json');
-      const statePath = path.join(cursorRoot, 'ecc-install-state.json');
+  if (test('supports dry-run without mutating managed files', () => {
+    const homeDir = createTempDir('uninstall-home-');
+    const projectRoot = createTempDir('uninstall-project-');

-      const uninstallResult = runNode(UNINSTALL_SCRIPT, ['--target', 'cursor', '--dry-run', '--json'], {
+    try {
+      const targetRoot = path.join(projectRoot, '.cursor');
+      fs.mkdirSync(targetRoot, { recursive: true });
+      const normalizedTargetRoot = fs.realpathSync(targetRoot);
+      const statePath = path.join(normalizedTargetRoot, 'ecc-install-state.json');
+      const renderedPath = path.join(normalizedTargetRoot, 'generated.md');
+      fs.writeFileSync(renderedPath, '# generated\n');
+
+      writeState(statePath, {
+        adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
+        targetRoot: normalizedTargetRoot,
+        installStatePath: statePath,
+        request: {
+          profile: null,
+          modules: ['platform-configs'],
+          includeComponents: [],
+          excludeComponents: [],
+          legacyLanguages: [],
+          legacyMode: false,
+        },
+        resolution: {
+          selectedModules: ['platform-configs'],
+          skippedModules: [],
+        },
+        operations: [
+          {
+            kind: 'render-template',
+            moduleId: 'platform-configs',
+            sourceRelativePath: '.cursor/generated.md.template',
+            destinationPath: renderedPath,
+            strategy: 'render-template',
+            ownership: 'managed',
+            scaffoldOnly: false,
+            renderedContent: '# generated\n',
+          },
+        ],
+        source: {
+          repoVersion: CURRENT_PACKAGE_VERSION,
+          repoCommit: 'abc123',
+          manifestVersion: CURRENT_MANIFEST_VERSION,
+        },
+      });
+
+      const uninstallResult = run(['--target', 'cursor', '--dry-run', '--json'], {
        cwd: projectRoot,
        homeDir,
      });
@@ -117,8 +270,8 @@ function runTests() {

      const parsed = JSON.parse(uninstallResult.stdout);
      assert.strictEqual(parsed.dryRun, true);
-      assert.ok(parsed.results[0].plannedRemovals.length > 0);
-      assert.ok(fs.existsSync(managedPath));
+      assert.ok(parsed.results[0].plannedRemovals.includes(renderedPath));
+      assert.ok(fs.existsSync(renderedPath));
      assert.ok(fs.existsSync(statePath));
    } finally {
      cleanup(homeDir);