claude-dev-env 2.8.0 → 2.10.0

package/bin/install.settings-defaults.test.mjs

@@ -0,0 +1,200 @@
+/**
+ * Managed permission defaults: pack inclusion, install merge, idempotence, uninstall.
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    mkdtempSync,
+    rmSync,
+    writeFileSync,
+    readFileSync,
+    existsSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+import {
+    managedDenyEntriesFromPackageSettings,
+    mergeManagedPermissionsIntoSettings,
+    pruneManagedPermissionsFromSettings,
+} from './merge_managed_permissions.mjs';
+
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const PACKAGE_SETTINGS_PATH = join(PACKAGE_ROOT, 'settings.json');
+const INSTALL_ENTRY = join(PACKAGE_ROOT, 'bin', 'install.mjs');
+
+const EXPECTED_DENY_ENTRIES = [
+    'Edit($HOME/.claude/verification/**)',
+    'Write($HOME/.claude/code-review-stamps/**)',
+    'Edit($HOME/.claude/code-review-stamps/**)',
+    'MultiEdit($HOME/.claude/code-review-stamps/**)',
+];
+
+function packageDenyEntries() {
+    const packageSettings = JSON.parse(readFileSync(PACKAGE_SETTINGS_PATH, 'utf8'));
+    return managedDenyEntriesFromPackageSettings(packageSettings);
+}
+
+function runInstallerInSandbox(sandboxHome, installerArguments = []) {
+    const gitConfigGlobal = join(sandboxHome, '.gitconfig-sandbox');
+    writeFileSync(gitConfigGlobal, '[safe]\n\tdirectory = *\n');
+    return spawnSync(process.execPath, [INSTALL_ENTRY, ...installerArguments], {
+        cwd: PACKAGE_ROOT,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: sandboxHome,
+            USERPROFILE: sandboxHome,
+            GIT_CONFIG_GLOBAL: gitConfigGlobal,
+        },
+    });
+}
+
+test('package settings.json publishes exactly the four managed deny entries', () => {
+    const denyEntries = packageDenyEntries();
+    assert.equal(denyEntries.length, 4);
+    assert.deepEqual(denyEntries, EXPECTED_DENY_ENTRIES);
+});
+
+test('an array-valued permissions field is replaced so managed denies survive a round trip', () => {
+    const targetSettings = { permissions: [] };
+    const result = mergeManagedPermissionsIntoSettings(targetSettings, EXPECTED_DENY_ENTRIES);
+    assert.equal(result.addedCount, EXPECTED_DENY_ENTRIES.length);
+    assert.equal(Array.isArray(targetSettings.permissions), false);
+    const roundTripped = JSON.parse(JSON.stringify(targetSettings));
+    assert.deepEqual(roundTripped.permissions.deny, EXPECTED_DENY_ENTRIES);
+});
+
+test('npm pack includes package settings.json in the published artifact', () => {
+    const packResult = spawnSync('npm', ['pack', '--dry-run', '--json'], {
+        cwd: PACKAGE_ROOT,
+        encoding: 'utf8',
+        shell: process.platform === 'win32',
+    });
+    assert.equal(packResult.status, 0, packResult.stderr || packResult.stdout);
+    const packPayload = JSON.parse(packResult.stdout);
+    const files = Array.isArray(packPayload)
+        ? packPayload[0]?.files ?? []
+        : packPayload.files ?? [];
+    const paths = files.map((eachFile) => (
+        typeof eachFile === 'string' ? eachFile : eachFile.path
+    ));
+    assert.ok(
+        paths.some((eachPath) => eachPath === 'settings.json' || eachPath.endsWith('/settings.json')),
+        `settings.json missing from pack files: ${paths.filter((p) => String(p).includes('settings')).join(', ') || 'none'}`,
+    );
+});
+
+test('mergeManagedPermissionsIntoSettings adds each package deny exactly once', () => {
+    const target = {
+        permissions: {
+            allow: ['Bash(git status)'],
+            deny: ['Bash(rm -rf /)'],
+        },
+    };
+    const first = mergeManagedPermissionsIntoSettings(target, EXPECTED_DENY_ENTRIES);
+    assert.equal(first.addedCount, 4);
+    assert.equal(first.alreadyPresentCount, 0);
+    assert.equal(target.permissions.deny.filter((each) => EXPECTED_DENY_ENTRIES.includes(each)).length, 4);
+    assert.ok(target.permissions.deny.includes('Bash(rm -rf /)'));
+    assert.deepEqual(target.permissions.allow, ['Bash(git status)']);
+
+    const second = mergeManagedPermissionsIntoSettings(target, EXPECTED_DENY_ENTRIES);
+    assert.equal(second.addedCount, 0);
+    assert.equal(second.alreadyPresentCount, 4);
+    assert.equal(
+        target.permissions.deny.filter((each) => each === EXPECTED_DENY_ENTRIES[0]).length,
+        1,
+    );
+});
+
+test('pruneManagedPermissionsFromSettings removes only package-owned deny entries', () => {
+    const target = {
+        permissions: {
+            allow: ['Bash(git status)'],
+            ask: ['Edit(./**)'],
+            deny: [
+                'Bash(rm -rf /)',
+                ...EXPECTED_DENY_ENTRIES,
+            ],
+        },
+    };
+    const outcome = pruneManagedPermissionsFromSettings(target, EXPECTED_DENY_ENTRIES);
+    assert.equal(outcome.removedCount, 4);
+    assert.deepEqual(target.permissions.deny, ['Bash(rm -rf /)']);
+    assert.deepEqual(target.permissions.allow, ['Bash(git status)']);
+    assert.deepEqual(target.permissions.ask, ['Edit(./**)']);
+});
+
+test('sandbox install adds all four deny entries once and is idempotent on repeat', () => {
+    const sandboxHome = mkdtempSync(join(tmpdir(), 'cde-settings-defaults-'));
+    try {
+        const firstInstall = runInstallerInSandbox(sandboxHome, []);
+        assert.equal(firstInstall.status, 0, firstInstall.stderr || firstInstall.stdout);
+
+        const settingsPath = join(sandboxHome, '.claude', 'settings.json');
+        assert.ok(existsSync(settingsPath), 'settings.json written');
+        const firstSettings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        const firstDeny = firstSettings.permissions?.deny ?? [];
+        for (const eachEntry of EXPECTED_DENY_ENTRIES) {
+            assert.ok(firstDeny.includes(eachEntry), `missing deny: ${eachEntry}`);
+            assert.equal(
+                firstDeny.filter((candidate) => candidate === eachEntry).length,
+                1,
+                `deny not unique: ${eachEntry}`,
+            );
+        }
+
+        const manifestPath = join(sandboxHome, '.claude', '.claude-dev-env-manifest.json');
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        assert.deepEqual(manifest.managedPermissions?.deny, EXPECTED_DENY_ENTRIES);
+
+        const secondInstall = runInstallerInSandbox(sandboxHome, []);
+        assert.equal(secondInstall.status, 0, secondInstall.stderr || secondInstall.stdout);
+        const secondSettings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        const secondDeny = secondSettings.permissions?.deny ?? [];
+        for (const eachEntry of EXPECTED_DENY_ENTRIES) {
+            assert.equal(
+                secondDeny.filter((candidate) => candidate === eachEntry).length,
+                1,
+                `repeat install duplicated deny: ${eachEntry}`,
+            );
+        }
+    } finally {
+        rmSync(sandboxHome, { recursive: true, force: true });
+    }
+});
+
+test('sandbox uninstall removes only package-owned permission entries and keeps user entries', () => {
+    const sandboxHome = mkdtempSync(join(tmpdir(), 'cde-settings-uninstall-'));
+    try {
+        const install = runInstallerInSandbox(sandboxHome, []);
+        assert.equal(install.status, 0, install.stderr || install.stdout);
+
+        const settingsPath = join(sandboxHome, '.claude', 'settings.json');
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        settings.permissions = settings.permissions ?? {};
+        settings.permissions.allow = [...(settings.permissions.allow ?? []), 'Bash(git status)'];
+        settings.permissions.ask = [...(settings.permissions.ask ?? []), 'Edit(./**)'];
+        settings.permissions.deny = [...(settings.permissions.deny ?? []), 'Bash(rm -rf /)'];
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 4) + '\n');
+
+        const uninstall = runInstallerInSandbox(sandboxHome, ['--uninstall']);
+        assert.equal(uninstall.status, 0, uninstall.stderr || uninstall.stdout);
+
+        assert.ok(existsSync(settingsPath), 'settings.json remains for user entries');
+        const after = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        const denyAfter = after.permissions?.deny ?? [];
+        for (const eachEntry of EXPECTED_DENY_ENTRIES) {
+            assert.ok(!denyAfter.includes(eachEntry), `managed deny still present: ${eachEntry}`);
+        }
+        assert.ok(denyAfter.includes('Bash(rm -rf /)'), 'user deny preserved');
+        assert.ok((after.permissions?.allow ?? []).includes('Bash(git status)'), 'user allow preserved');
+        assert.ok((after.permissions?.ask ?? []).includes('Edit(./**)'), 'user ask preserved');
+    } finally {
+        rmSync(sandboxHome, { recursive: true, force: true });
+    }
+});

package/bin/install.transaction.test.mjs

@@ -0,0 +1,400 @@
+/**
+ * Install transaction journal and fault-injection recovery (control-plane E2 / P-18).
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    existsSync,
+    mkdtempSync,
+    mkdirSync,
+    readFileSync,
+    rmSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFileSync, spawnSync } from 'node:child_process';
+import {
+    FAULT_PHASES,
+    INSTALL_FAULT_ENV,
+    InstallTransactionFaultError,
+    capturePriorInstallSnapshot,
+    discardInstallTransactionJournal,
+    readGlobalCoreHooksPath,
+    resolveFaultPhaseFromEnvironment,
+    restorePriorInstallSnapshot,
+    runWithInstallTransaction,
+    throwIfFaultPhase,
+    writeGlobalCoreHooksPath,
+} from './install-transaction.mjs';
+
+const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
+const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
+
+function sandbox() {
+    const root = mkdtempSync(join(tmpdir(), 'cdev-txn-'));
+    const managedRoot = join(root, 'managed');
+    mkdirSync(managedRoot, { recursive: true });
+    return {
+        root,
+        managedRoot,
+        settingsPath: join(managedRoot, 'settings.json'),
+        manifestFilePath: join(managedRoot, '.claude-dev-env-manifest.json'),
+        journalParent: join(managedRoot, '.claude-dev-env-txn'),
+    };
+}
+
+function writeFileWithParents(filePath, contents) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, contents);
+}
+
+test('resolveFaultPhaseFromEnvironment accepts known phases and rejects unknown', () => {
+    assert.equal(resolveFaultPhaseFromEnvironment({}), null);
+    assert.equal(
+        resolveFaultPhaseFromEnvironment({ [INSTALL_FAULT_ENV]: FAULT_PHASES.AFTER_SETTINGS_WRITE }),
+        FAULT_PHASES.AFTER_SETTINGS_WRITE,
+    );
+    assert.throws(
+        () => resolveFaultPhaseFromEnvironment({ [INSTALL_FAULT_ENV]: 'not-a-phase' }),
+        /Unknown/,
+    );
+});
+
+test('throwIfFaultPhase throws only on the matching phase', () => {
+    assert.doesNotThrow(() => throwIfFaultPhase(FAULT_PHASES.AFTER_FILE_STAGING, null));
+    assert.doesNotThrow(
+        () => throwIfFaultPhase(FAULT_PHASES.AFTER_FILE_STAGING, FAULT_PHASES.AFTER_SETTINGS_WRITE),
+    );
+    assert.throws(
+        () => throwIfFaultPhase(FAULT_PHASES.AFTER_GIT_CONFIG, FAULT_PHASES.AFTER_GIT_CONFIG),
+        (error) => error instanceof InstallTransactionFaultError
+            && error.phase === FAULT_PHASES.AFTER_GIT_CONFIG,
+    );
+});
+
+test('capture and restore recover settings, manifest, files, and hooksPath', () => {
+    const box = sandbox();
+    const gitConfigPath = join(box.root, '.gitconfig');
+    writeFileSync(gitConfigPath, '');
+    const priorHooksDirectory = join(box.managedRoot, 'hooks', 'git-hooks');
+    mkdirSync(priorHooksDirectory, { recursive: true });
+    const env = {
+        ...process.env,
+        HOME: box.root,
+        USERPROFILE: box.root,
+        GIT_CONFIG_GLOBAL: gitConfigPath,
+    };
+    const io = { env, execFileSync };
+
+    writeFileWithParents(box.settingsPath, '{"hooks":{"SessionStart":[]}}\n');
+    const priorFile = join(box.managedRoot, 'rules', 'keep.md');
+    writeFileWithParents(priorFile, 'prior-rules\n');
+    writeFileWithParents(
+        box.manifestFilePath,
+        `${JSON.stringify({ files: [priorFile], skills: ['keep'] }, null, 2)}\n`,
+    );
+    writeGlobalCoreHooksPath(priorHooksDirectory, io);
+
+    const snapshot = capturePriorInstallSnapshot({
+        managedRoot: box.managedRoot,
+        manifestFilePath: box.manifestFilePath,
+        settingsPath: box.settingsPath,
+        priorManifestFiles: [priorFile],
+        journalParentDirectory: box.journalParent,
+        io,
+    });
+    assert.equal(snapshot.settingsExisted, true);
+    assert.equal(snapshot.manifestExisted, true);
+    assert.equal(snapshot.priorHooksPath, priorHooksDirectory);
+    assert.equal(snapshot.allFileEntries.length, 1);
+
+    const newFile = join(box.managedRoot, 'rules', 'new.md');
+    writeFileWithParents(newFile, 'new-content\n');
+    writeFileSync(priorFile, 'corrupted\n');
+    writeFileSync(box.settingsPath, '{"hooks":{"broken":true}}\n');
+    writeFileSync(box.manifestFilePath, '{"files":[],"skills":[]}\n');
+    writeGlobalCoreHooksPath(join(box.managedRoot, 'other-hooks'), io);
+
+    restorePriorInstallSnapshot(snapshot, {
+        allWrittenPaths: [newFile, priorFile, box.settingsPath, box.manifestFilePath],
+        io,
+    });
+
+    assert.equal(readFileSync(priorFile, 'utf8'), 'prior-rules\n');
+    assert.equal(readFileSync(box.settingsPath, 'utf8'), '{"hooks":{"SessionStart":[]}}\n');
+    assert.deepEqual(JSON.parse(readFileSync(box.manifestFilePath, 'utf8')).skills, ['keep']);
+    assert.equal(existsSync(newFile), false);
+    assert.equal(readGlobalCoreHooksPath(io), priorHooksDirectory);
+
+    discardInstallTransactionJournal(snapshot);
+    rmSync(box.root, { recursive: true, force: true });
+});
+
+test('runWithInstallTransaction restores prior state on injected fault', () => {
+    const box = sandbox();
+    const gitConfigPath = join(box.root, '.gitconfig');
+    writeFileSync(gitConfigPath, '');
+    const env = {
+        ...process.env,
+        HOME: box.root,
+        USERPROFILE: box.root,
+        GIT_CONFIG_GLOBAL: gitConfigPath,
+    };
+    const io = { env, execFileSync };
+    const priorFile = join(box.managedRoot, 'docs', 'a.md');
+    writeFileWithParents(priorFile, 'keep-me\n');
+    writeFileWithParents(box.settingsPath, '{"ok":true}\n');
+    writeFileWithParents(
+        box.manifestFilePath,
+        `${JSON.stringify({ files: [priorFile], skills: [] })}\n`,
+    );
+
+    const snapshot = capturePriorInstallSnapshot({
+        managedRoot: box.managedRoot,
+        manifestFilePath: box.manifestFilePath,
+        settingsPath: box.settingsPath,
+        priorManifestFiles: [priorFile],
+        journalParentDirectory: box.journalParent,
+        io,
+    });
+
+    assert.throws(
+        () => runWithInstallTransaction({
+            snapshot,
+            faultPhase: FAULT_PHASES.AFTER_SETTINGS_WRITE,
+            io,
+            runMutations: ({ throwIfFault, recordWrittenPath }) => {
+                writeFileSync(priorFile, 'mutated\n');
+                recordWrittenPath(priorFile);
+                writeFileSync(box.settingsPath, '{"ok":false}\n');
+                recordWrittenPath(box.settingsPath);
+                throwIfFault(FAULT_PHASES.AFTER_SETTINGS_WRITE);
+                writeFileSync(box.manifestFilePath, '{"files":[]}\n');
+            },
+        }),
+        (error) => error instanceof InstallTransactionFaultError,
+    );
+
+    assert.equal(readFileSync(priorFile, 'utf8'), 'keep-me\n');
+    assert.equal(readFileSync(box.settingsPath, 'utf8'), '{"ok":true}\n');
+    assert.deepEqual(JSON.parse(readFileSync(box.manifestFilePath, 'utf8')).files, [priorFile]);
+    rmSync(box.root, { recursive: true, force: true });
+});
+
+test('runWithInstallTransaction commits and discards journal on success', () => {
+    const box = sandbox();
+    const gitConfigPath = join(box.root, '.gitconfig');
+    writeFileSync(gitConfigPath, '');
+    const io = {
+        env: {
+            ...process.env,
+            HOME: box.root,
+            USERPROFILE: box.root,
+            GIT_CONFIG_GLOBAL: gitConfigPath,
+        },
+        execFileSync,
+    };
+    const priorFile = join(box.managedRoot, 'docs', 'a.md');
+    writeFileWithParents(priorFile, 'v1\n');
+    writeFileWithParents(
+        box.manifestFilePath,
+        `${JSON.stringify({ files: [priorFile], skills: [] })}\n`,
+    );
+    const snapshot = capturePriorInstallSnapshot({
+        managedRoot: box.managedRoot,
+        manifestFilePath: box.manifestFilePath,
+        settingsPath: box.settingsPath,
+        priorManifestFiles: [priorFile],
+        journalParentDirectory: box.journalParent,
+        io,
+    });
+    const journalRoot = snapshot.journalRoot;
+
+    runWithInstallTransaction({
+        snapshot,
+        faultPhase: null,
+        io,
+        runMutations: ({ throwIfFault, recordWrittenPath }) => {
+            writeFileSync(priorFile, 'v2\n');
+            recordWrittenPath(priorFile);
+            throwIfFault(FAULT_PHASES.AFTER_FILE_STAGING);
+        },
+    });
+
+    assert.equal(readFileSync(priorFile, 'utf8'), 'v2\n');
+    assert.equal(existsSync(journalRoot), false);
+    rmSync(box.root, { recursive: true, force: true });
+});
+
+/**
+ * Spawn the real installer against a sandbox home with optional fault phase.
+ *
+ * @param {string} homeDirectory
+ * @param {string[]} extraArguments
+ * @param {{ faultPhase?: string|null }} [options]
+ */
+function runInstaller(homeDirectory, extraArguments, options = {}) {
+    const childEnvironment = {
+        ...process.env,
+        HOME: homeDirectory,
+        USERPROFILE: homeDirectory,
+        GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+    };
+    if (options.faultPhase) {
+        childEnvironment[INSTALL_FAULT_ENV] = options.faultPhase;
+    } else {
+        delete childEnvironment[INSTALL_FAULT_ENV];
+    }
+    return spawnSync(process.execPath, [INSTALLER_PATH, ...extraArguments], {
+        cwd: THIS_DIRECTORY,
+        encoding: 'utf8',
+        env: childEnvironment,
+    });
+}
+
+function seedPriorInstall(homeDirectory) {
+    const claudeDirectory = join(homeDirectory, '.claude');
+    const rulesFile = join(claudeDirectory, 'rules', 'prior.md');
+    writeFileWithParents(rulesFile, 'prior-body\n');
+    writeFileWithParents(
+        join(claudeDirectory, 'settings.json'),
+        `${JSON.stringify({ hooks: { UserPromptSubmit: [] }, customMarker: 'prior-settings' }, null, 2)}\n`,
+    );
+    writeFileWithParents(
+        join(claudeDirectory, '.claude-dev-env-manifest.json'),
+        `${JSON.stringify({
+            packageName: 'claude-dev-env',
+            files: [rulesFile],
+            skills: [],
+        }, null, 2)}\n`,
+    );
+    writeFileSync(join(homeDirectory, '.gitconfig'), '');
+    return { claudeDirectory, rulesFile };
+}
+
+test('installer fault after_file_staging restores prior managed installation', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-txn-e2e-'));
+    try {
+        const { claudeDirectory, rulesFile } = seedPriorInstall(homeDirectory);
+        const priorSettings = readFileSync(join(claudeDirectory, 'settings.json'), 'utf8');
+        const priorManifest = readFileSync(
+            join(claudeDirectory, '.claude-dev-env-manifest.json'),
+            'utf8',
+        );
+
+        const failedRun = runInstaller(homeDirectory, ['--only', 'journal'], {
+            faultPhase: FAULT_PHASES.AFTER_FILE_STAGING,
+        });
+        assert.notEqual(failedRun.status, 0, failedRun.stdout + failedRun.stderr);
+        assert.match(`${failedRun.stdout}${failedRun.stderr}`, /fault|restored|aborted/i);
+
+        assert.equal(readFileSync(rulesFile, 'utf8'), 'prior-body\n');
+        assert.equal(readFileSync(join(claudeDirectory, 'settings.json'), 'utf8'), priorSettings);
+        assert.equal(
+            readFileSync(join(claudeDirectory, '.claude-dev-env-manifest.json'), 'utf8'),
+            priorManifest,
+        );
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('installer fault after_settings_write restores prior settings and files', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-txn-e2e-settings-'));
+    try {
+        const { claudeDirectory, rulesFile } = seedPriorInstall(homeDirectory);
+        const priorSettings = readFileSync(join(claudeDirectory, 'settings.json'), 'utf8');
+
+        const failedRun = runInstaller(homeDirectory, [], {
+            faultPhase: FAULT_PHASES.AFTER_SETTINGS_WRITE,
+        });
+        assert.notEqual(failedRun.status, 0, failedRun.stdout + failedRun.stderr);
+        assert.equal(readFileSync(join(claudeDirectory, 'settings.json'), 'utf8'), priorSettings);
+        assert.equal(readFileSync(rulesFile, 'utf8'), 'prior-body\n');
+        assert.match(
+            readFileSync(join(claudeDirectory, '.claude-dev-env-manifest.json'), 'utf8'),
+            /prior\.md|prior-body|claude-dev-env/,
+        );
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('installer fault after_manifest_write restores prior manifest', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-txn-e2e-manifest-'));
+    try {
+        const { claudeDirectory } = seedPriorInstall(homeDirectory);
+        const priorManifest = readFileSync(
+            join(claudeDirectory, '.claude-dev-env-manifest.json'),
+            'utf8',
+        );
+
+        const failedRun = runInstaller(homeDirectory, ['--only', 'journal'], {
+            faultPhase: FAULT_PHASES.AFTER_MANIFEST_WRITE,
+        });
+        assert.notEqual(failedRun.status, 0, failedRun.stdout + failedRun.stderr);
+        assert.equal(
+            readFileSync(join(claudeDirectory, '.claude-dev-env-manifest.json'), 'utf8'),
+            priorManifest,
+        );
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('installer fault after_git_config restores prior core.hooksPath', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-txn-e2e-git-'));
+    try {
+        seedPriorInstall(homeDirectory);
+        const gitConfigPath = join(homeDirectory, '.gitconfig');
+        const priorHooksPath = join(homeDirectory, 'prior-git-hooks');
+        mkdirSync(priorHooksPath, { recursive: true });
+        writeGlobalCoreHooksPath(priorHooksPath, {
+            env: {
+                ...process.env,
+                HOME: homeDirectory,
+                USERPROFILE: homeDirectory,
+                GIT_CONFIG_GLOBAL: gitConfigPath,
+            },
+            execFileSync,
+        });
+
+        const failedRun = runInstaller(homeDirectory, [], {
+            faultPhase: FAULT_PHASES.AFTER_GIT_CONFIG,
+        });
+        assert.notEqual(failedRun.status, 0, failedRun.stdout + failedRun.stderr);
+
+        const restored = readGlobalCoreHooksPath({
+            env: {
+                ...process.env,
+                HOME: homeDirectory,
+                USERPROFILE: homeDirectory,
+                GIT_CONFIG_GLOBAL: gitConfigPath,
+            },
+            execFileSync,
+        });
+        assert.equal(restored, priorHooksPath);
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('successful install after prior install leaves one manifest and no fault', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-txn-e2e-ok-'));
+    try {
+        seedPriorInstall(homeDirectory);
+        const okRun = runInstaller(homeDirectory, ['--only', 'journal']);
+        assert.equal(okRun.status, 0, okRun.stdout + okRun.stderr);
+        const manifestPath = join(homeDirectory, '.claude', '.claude-dev-env-manifest.json');
+        assert.equal(existsSync(manifestPath), true);
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        assert.ok(Array.isArray(manifest.files));
+        assert.equal(existsSync(join(homeDirectory, '.claude', '.claude-dev-env-txn')), false);
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+