claude-dev-env 4.3.0 → 7.1.0

package/bin/expand_home_directory_tokens.test.mjs

@@ -0,0 +1,128 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+
+import {
+    expandHomeDirectoryTokens,
+    expandHomeDirectoryTokensInSettings,
+} from './expand_home_directory_tokens.mjs';
+
+
+test('expandHomeDirectoryTokens expands $HOME, ${HOME}, and ~/', () => {
+    assert.equal(
+        expandHomeDirectoryTokens(
+            'python $HOME/.claude/hooks/session/fix_worktree_hookspath.py',
+            'C:\\Users\\x',
+        ),
+        'python C:/Users/x/.claude/hooks/session/fix_worktree_hookspath.py',
+    );
+    assert.equal(
+        expandHomeDirectoryTokens('python ${HOME}/.claude/hooks/a.py', '/home/x'),
+        'python /home/x/.claude/hooks/a.py',
+    );
+    assert.equal(
+        expandHomeDirectoryTokens('python ~/.claude/hooks/a.py', '/home/x'),
+        'python /home/x/.claude/hooks/a.py',
+    );
+    assert.equal(
+        expandHomeDirectoryTokens('echo $HOMEPATH', 'C:/Users/x'),
+        'echo $HOMEPATH',
+    );
+});
+
+
+test('expandHomeDirectoryTokens inserts dollar characters in home paths literally', () => {
+    const homeWithReplaceMetacharacters = 'C:/Users/$&evil$1';
+    assert.equal(
+        expandHomeDirectoryTokens('python $HOME/.claude/a.py', homeWithReplaceMetacharacters),
+        'python C:/Users/$&evil$1/.claude/a.py',
+    );
+    assert.equal(
+        expandHomeDirectoryTokens('python ${HOME}/.claude/a.py', homeWithReplaceMetacharacters),
+        'python C:/Users/$&evil$1/.claude/a.py',
+    );
+    assert.equal(
+        expandHomeDirectoryTokens('python ~/.claude/a.py', homeWithReplaceMetacharacters),
+        'python C:/Users/$&evil$1/.claude/a.py',
+    );
+});
+
+
+test('expandHomeDirectoryTokens expands ${HOME} before $HOME so braces stay intact', () => {
+    assert.equal(
+        expandHomeDirectoryTokens('python ${HOME}/.claude/a.py', '/home/x'),
+        'python /home/x/.claude/a.py',
+    );
+});
+
+
+test('expandHomeDirectoryTokens strips trailing slashes from the home directory', () => {
+    assert.equal(
+        expandHomeDirectoryTokens('python $HOME/.claude/a.py', 'C:/Users/x/'),
+        'python C:/Users/x/.claude/a.py',
+    );
+});
+
+
+test('expandHomeDirectoryTokensInSettings skips non-array hook event values', () => {
+    const settings = {
+        hooks: {
+            SessionStart: 'not-an-array',
+            PreToolUse: [
+                {
+                    matcher: 'Write',
+                    hooks: [{ type: 'command', command: 'python $HOME/.claude/hooks/a.py' }],
+                },
+            ],
+        },
+    };
+    expandHomeDirectoryTokensInSettings(settings, 'C:/Users/x');
+    assert.equal(settings.hooks.SessionStart, 'not-an-array');
+    assert.equal(
+        settings.hooks.PreToolUse[0].hooks[0].command,
+        'python C:/Users/x/.claude/hooks/a.py',
+    );
+});
+
+
+test('expandHomeDirectoryTokensInSettings rewrites hooks and statusLine', () => {
+    const settings = {
+        hooks: {
+            SessionStart: [
+                {
+                    matcher: '',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: 'python $HOME/.claude/hooks/session/fix_worktree_hookspath.py',
+                        },
+                    ],
+                },
+            ],
+        },
+        statusLine: {
+            type: 'command',
+            command: 'python "$HOME/.claude/statusline-command.py"',
+        },
+    };
+    expandHomeDirectoryTokensInSettings(settings, 'C:/Users/x');
+    assert.equal(
+        settings.hooks.SessionStart[0].hooks[0].command,
+        'python C:/Users/x/.claude/hooks/session/fix_worktree_hookspath.py',
+    );
+    assert.equal(
+        settings.statusLine.command,
+        'python "C:/Users/x/.claude/statusline-command.py"',
+    );
+});
+
+
+test('expandHomeDirectoryTokens expands a tilde path that follows a semicolon or an opening parenthesis', () => {
+    assert.equal(
+        expandHomeDirectoryTokens('cd /repo;~/.claude/hooks/x.py', '/home/x'),
+        'cd /repo;/home/x/.claude/hooks/x.py',
+    );
+    assert.equal(
+        expandHomeDirectoryTokens('(~/.claude/hooks/x.py)', '/home/x'),
+        '(/home/x/.claude/hooks/x.py)',
+    );
+});

package/bin/git_hooks_installer.mjs

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 export const KNOWN_GIT_HOOK_NAMES = Object.freeze([
     'pre-commit',
     'pre-push',
+    'post-commit',
 ]);
 
 export const SHIM_DOCSTRING = (
@@ -72,6 +73,12 @@ function deriveModuleNameFromGitNativeHookName(gitNativeHookName) {
 
 function buildShimContent(pythonModuleName) {
     const shimContentHeader = '#!/usr/bin/env python3\n';
+    const failureMessage = JSON.stringify(
+        `claude-dev-env: advisory hook ${pythonModuleName} failed: `,
+    );
+    const nonzeroMessage = JSON.stringify(
+        `claude-dev-env: advisory hook ${pythonModuleName} returned non-zero: `,
+    );
     return (
         shimContentHeader
         + `"""${SHIM_DOCSTRING}"""\n`
@@ -82,9 +89,21 @@ function buildShimContent(pythonModuleName) {
         + 'if str(shim_directory) not in sys.path:\n'
         + '    sys.path.insert(0, str(shim_directory))\n'
         + '\n'
-        + `import ${pythonModuleName}\n`
-        + '\n'
-        + `sys.exit(${pythonModuleName}.main())\n`
+        + 'try:\n'
+        + `    import ${pythonModuleName}\n`
+        + `    advisory_exit_code = ${pythonModuleName}.main()\n`
+        + 'except SystemExit as advisory_system_exit:\n'
+        + '    if advisory_system_exit.code == 130:\n'
+        + '        raise\n'
+        + '    if advisory_system_exit.code not in (None, 0):\n'
+        + `        print(${failureMessage} + str(advisory_system_exit), file=sys.stderr)\n`
+        + '    sys.exit(0)\n'
+        + 'except Exception as advisory_error:\n'
+        + `    print(${failureMessage} + str(advisory_error), file=sys.stderr)\n`
+        + '    sys.exit(0)\n'
+        + 'if advisory_exit_code:\n'
+        + `    print(${nonzeroMessage} + str(advisory_exit_code), file=sys.stderr)\n`
+        + 'sys.exit(0)\n'
     );
 }
 

package/bin/git_hooks_installer.test.mjs

@@ -1,6 +1,7 @@
 import { test } from 'node:test';
 import { strict as assert } from 'node:assert';
-import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync, statSync, symlinkSync } from 'node:fs';
+import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -58,16 +59,16 @@ test('writeAllGitHookShims creates one shim per known hook name', () => {
 });
 
 
-test('known git hooks exclude post-commit', () => {
-    assert.equal(KNOWN_GIT_HOOK_NAMES.includes('post-commit'), false);
+test('known git hooks include post-commit for current-head notices', () => {
+    assert.deepEqual(KNOWN_GIT_HOOK_NAMES, ['pre-commit', 'pre-push', 'post-commit']);
 });
 
 
-test('writeAllGitHookShims does not create a post-commit shim', () => {
+test('writeAllGitHookShims creates the post-commit shim', () => {
     const { temporaryRoot, gitHooksDirectory } = makeTemporaryGitHooksDirectory();
     try {
         writeAllGitHookShims({ gitHooksDirectory });
-        assert.equal(existsSync(join(gitHooksDirectory, 'post-commit')), false);
+        assert.equal(existsSync(join(gitHooksDirectory, 'post-commit')), true);
     } finally {
         rmSync(temporaryRoot, { recursive: true, force: true });
     }
@@ -221,3 +222,156 @@ test('writeGitHookShim rejects hooks directory that is a symlink (loopP5c-5)', (
     }
 });
 
+
+test('generated advisory shims keep temporary Git commit and push available after module failure', () => {
+    const { temporaryRoot, gitHooksDirectory } = makeTemporaryGitHooksDirectory();
+    const repositoryRoot = join(temporaryRoot, 'repository');
+    const bareRepositoryRoot = join(temporaryRoot, 'remote.git');
+    const targetRemote = 'https://github.com/JonEcho/python-automation.git';
+    try {
+        writeFileSync(
+            join(gitHooksDirectory, 'broken_advisory.py'),
+            'def main():\n    raise RuntimeError("advisory failure")\n',
+        );
+        writeGitHookShim({
+            gitHooksDirectory,
+            gitNativeHookName: 'pre-commit',
+            pythonModuleName: 'broken_advisory',
+        });
+        writeGitHookShim({
+            gitHooksDirectory,
+            gitNativeHookName: 'pre-push',
+            pythonModuleName: 'broken_advisory',
+        });
+        mkdirSync(repositoryRoot);
+        execFileSync('git', ['init', '--initial-branch=main', '--quiet'], { cwd: repositoryRoot });
+        execFileSync('git', ['config', 'user.email', 'test@example.invalid'], { cwd: repositoryRoot });
+        execFileSync('git', ['config', 'user.name', 'Verification Test'], { cwd: repositoryRoot });
+        execFileSync('git', ['config', 'core.hooksPath', gitHooksDirectory], { cwd: repositoryRoot });
+        writeFileSync(join(repositoryRoot, 'README.md'), 'check\n');
+        execFileSync('git', ['add', 'README.md'], { cwd: repositoryRoot });
+
+        const commitResult = spawnSync('git', ['commit', '-m', 'initial'], {
+            cwd: repositoryRoot,
+            encoding: 'utf8',
+        });
+        assert.equal(commitResult.status, 0);
+        assert.match(commitResult.stderr, /advisory hook broken_advisory failed: advisory failure/);
+
+        execFileSync('git', ['init', '--bare', '--quiet', bareRepositoryRoot], { cwd: temporaryRoot });
+        execFileSync('git', ['remote', 'add', 'origin', targetRemote], { cwd: repositoryRoot });
+        execFileSync('git', ['config', `url.${bareRepositoryRoot}.insteadOf`, targetRemote], {
+            cwd: repositoryRoot,
+        });
+        const pushResult = spawnSync('git', ['push', 'origin', 'main'], {
+            cwd: repositoryRoot,
+            encoding: 'utf8',
+        });
+        assert.equal(pushResult.status, 0);
+        assert.match(pushResult.stderr, /advisory hook broken_advisory failed: advisory failure/);
+    } finally {
+        rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+});
+
+
+test('generated advisory shim turns a nonzero module return into a success with a warning', () => {
+    const { temporaryRoot, gitHooksDirectory } = makeTemporaryGitHooksDirectory();
+    try {
+        writeFileSync(
+            join(gitHooksDirectory, 'nonzero_advisory.py'),
+            'def main():\n    return 1\n',
+        );
+        const shimPath = writeGitHookShim({
+            gitHooksDirectory,
+            gitNativeHookName: 'pre-commit',
+            pythonModuleName: 'nonzero_advisory',
+        });
+        const shimResult = spawnSync('python', [shimPath], {
+            encoding: 'utf8',
+        });
+        assert.equal(shimResult.status, 0);
+        assert.match(shimResult.stderr, /advisory hook nonzero_advisory returned non-zero: 1/);
+    } finally {
+        rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+});
+
+
+function runGeneratedAdvisoryModule(pythonModuleName, moduleSource) {
+    const { temporaryRoot, gitHooksDirectory } = makeTemporaryGitHooksDirectory();
+    try {
+        if (moduleSource !== null) {
+            writeFileSync(join(gitHooksDirectory, pythonModuleName + '.py'), moduleSource);
+        }
+        const shimPath = writeGitHookShim({
+            gitHooksDirectory,
+            gitNativeHookName: 'pre-commit',
+            pythonModuleName,
+        });
+        return spawnSync('python', [shimPath], {
+            encoding: 'utf8',
+        });
+    } finally {
+        rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+}
+
+
+test('generated advisory shim reports a missing module and succeeds', () => {
+    const shimResult = runGeneratedAdvisoryModule('missing_advisory', null);
+    assert.equal(shimResult.status, 0);
+    assert.match(shimResult.stderr, /advisory hook missing_advisory failed: No module named/);
+});
+
+
+test('generated advisory shim reports a syntax error and succeeds', () => {
+    const shimResult = runGeneratedAdvisoryModule(
+        'broken_syntax',
+        'def main(:\n    return 1\n',
+    );
+    assert.equal(shimResult.status, 0);
+    assert.match(shimResult.stderr, /advisory hook broken_syntax failed:/);
+});
+
+
+test('generated advisory shim reports ordinary SystemExit and succeeds', () => {
+    const shimResult = runGeneratedAdvisoryModule(
+        'ordinary_exit',
+        'def main():\n    raise SystemExit(1)\n',
+    );
+    assert.equal(shimResult.status, 0);
+    assert.match(shimResult.stderr, /advisory hook ordinary_exit failed: 1/);
+});
+
+
+test('generated advisory shim treats successful SystemExit as silent success', () => {
+    for (const [pythonModuleName, moduleSource] of [
+        ['zero_exit', 'def main():\n    raise SystemExit(0)\n'],
+        ['empty_exit', 'def main():\n    raise SystemExit()\n'],
+    ]) {
+        const shimResult = runGeneratedAdvisoryModule(pythonModuleName, moduleSource);
+        assert.equal(shimResult.status, 0);
+        assert.equal(shimResult.stderr, '');
+    }
+});
+
+
+test('generated advisory shim preserves cancellation SystemExit 130', () => {
+    const shimResult = runGeneratedAdvisoryModule(
+        'cancelled_exit',
+        'def main():\n    raise SystemExit(130)\n',
+    );
+    assert.equal(shimResult.status, 130);
+    assert.doesNotMatch(shimResult.stderr, /advisory hook cancelled_exit/);
+});
+
+
+test('generated advisory shim preserves KeyboardInterrupt cancellation', () => {
+    const shimResult = runGeneratedAdvisoryModule(
+        'keyboard_cancel',
+        'def main():\n    raise KeyboardInterrupt()\n',
+    );
+    assert.notEqual(shimResult.status, 0);
+    assert.match(shimResult.stderr, /KeyboardInterrupt/);
+});

package/bin/install-session-continuity.mjs

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function continuityHookConfiguration(host, script) {
+    if (host === 'cursor') {
+        throw new Error('Cursor automatic activation is unsupported: beforeSubmitPrompt has no agent-context output, sessionStart is fire-and-forget, and preCompact is observational. No Cursor settings changed.');
+    }
+    if (!['claude', 'codex'].includes(host)) throw new Error(`Unsupported host ${host}`);
+    if (/[\r\n"`$%]/.test(script)) throw new Error('Hook script path contains shell expansion characters');
+    const command = `node "${script.replace(/\\/g, '/')}" hook ${host}`;
+    const events = host === 'claude' ? ['UserPromptSubmit', 'UserPromptExpansion', 'SessionStart'] : ['UserPromptSubmit', 'SessionStart'];
+    return Object.fromEntries(events.map(event => [event, [{
+        ...(event === 'SessionStart' ? { matcher: host === 'claude' ? 'startup|resume|compact|clear|fork' : 'startup|resume|compact|clear' } : {}),
+        ...(event === 'UserPromptExpansion' ? { matcher: '^(pstack:)?poteto-mode$|^(claude-dev-env:)?session-continuity$' } : {}),
+        hooks: [{ type: 'command', command, timeout: 10 }],
+    }]]));
+}
+
+export function mergeContinuityHooks(existing, host, script) {
+    const additions = continuityHookConfiguration(host, script);
+    const mergedConfiguration = structuredClone(existing);
+    mergedConfiguration.hooks ||= {};
+    for (const [event, groups] of Object.entries(additions)) {
+        const current = mergedConfiguration.hooks[event] || [];
+        for (const group of current) {
+            for (const hook of group.hooks || []) {
+                if (hook.command?.includes('/session-continuity/continuity.mjs') && hook.command !== groups[0].hooks[0].command) {
+                    throw new Error('Another continuity installation owns this host config. Select its profile or remove that installation explicitly.');
+                }
+            }
+        }
+        const kept = current.flatMap(group => {
+            const hooks = (group.hooks || []).filter(hook => hook.command !== groups[0].hooks[0].command);
+            return hooks.length ? [{ ...group, hooks }] : [];
+        });
+        mergedConfiguration.hooks[event] = kept.concat(groups);
+    }
+    return mergedConfiguration;
+}
+
+async function main() {
+    const requested = process.argv.slice(2);
+    const selected = requested.length ? requested : ['claude', 'codex'];
+    if (selected.some(host => !['claude', 'codex'].includes(host))) continuityHookConfiguration(selected.find(host => !['claude', 'codex'].includes(host)), '');
+    const { resolveInstallRoot } = await import('./resolve-install-root.mjs');
+    const roots = resolveInstallRoot();
+    const script = join(roots.skillsInstallDirectory, 'session-continuity', 'continuity.mjs');
+    if (!existsSync(script) || !existsSync(join(dirname(script), 'SKILL.md'))) {
+        throw new Error('Run the full claude-dev-env installer from this checkout first so the companion is in the canonical agents home.');
+    }
+    const paths = { claude: join(roots.managedRoot, 'settings.json'), codex: join(dirname(roots.codexRulesInstallDirectory), 'hooks.json') };
+    const plans = selected.map(host => {
+        const path = paths[host];
+        if (!existsSync(dirname(path))) throw new Error(`Host config directory is absent: ${dirname(path)}`);
+        const existing = existsSync(path) ? readFileSync(path, 'utf8') : null;
+        return { path, existing, content: JSON.stringify(mergeContinuityHooks(existing ? JSON.parse(existing) : {}, host, script), null, 2) + '\n' };
+    });
+    for (const plan of plans) {
+        if (plan.existing === plan.content) { console.log(`Already configured: ${plan.path}`); continue; }
+        if (plan.existing !== null) {
+            const backup = `${plan.path}.before-session-continuity`;
+            if (!existsSync(backup)) writeFileSync(backup, plan.existing, { flag: 'wx', mode: 0o600 });
+        }
+        const current = existsSync(plan.path) ? readFileSync(plan.path, 'utf8') : null;
+        if (current !== plan.existing) throw new Error(`Config changed during setup: ${plan.path}. Rerun setup.`);
+        const temporary = `${plan.path}.continuity-${process.pid}.tmp`;
+        writeFileSync(temporary, plan.content, { flag: 'wx', mode: 0o600 });
+        renameSync(temporary, plan.path);
+        if (readFileSync(plan.path, 'utf8') !== plan.content) throw new Error(`Config read-back mismatch: ${plan.path}`);
+        console.log(`Configured and read back: ${plan.path}`);
+    }
+    console.log('Review and trust the new hooks in each host. Cursor remains unsupported; no Cursor settings changed.');
+}
+
+if (process.argv[1] && resolve(realpathSync(process.argv[1])) === fileURLToPath(import.meta.url)) {
+    main().catch(error => { console.error(error.message); process.exitCode = 1; });
+}

package/bin/install-session-continuity.test.mjs

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { continuityHookConfiguration, mergeContinuityHooks } from './install-session-continuity.mjs';
+
+test('setup preserves other hooks and settings, is idempotent, and rejects competing profiles', () => {
+    const existing = { permissions: { deny: ['secret'] }, hooks: { SessionStart: [{ hooks: [{ type: 'command', command: 'existing-hook' }] }] } };
+    const script = '/home/jon/.agents/skills/session-continuity/continuity.mjs';
+    const first = mergeContinuityHooks(existing, 'claude', script);
+    assert.deepEqual(mergeContinuityHooks(first, 'claude', script), first);
+    assert.deepEqual(first.permissions, existing.permissions);
+    assert.equal(first.hooks.SessionStart[0].hooks[0].command, 'existing-hook');
+    assert.equal(existing.hooks.SessionStart.length, 1);
+    assert.throws(() => mergeContinuityHooks(first, 'claude', '/other/session-continuity/continuity.mjs'), /Another continuity installation/);
+    assert.throws(() => continuityHookConfiguration('claude', '/path/with$expansion/continuity.mjs'), /expansion/);
+});
+
+test('Cursor setup refuses an unsupported automatic activation claim without changing config', () => {
+    const existing = { version: 1, hooks: { beforeSubmitPrompt: [{ command: 'existing' }] } };
+    const before = JSON.stringify(existing);
+    assert.throws(() => mergeContinuityHooks(existing, 'cursor', '/skill/continuity.mjs'), /beforeSubmitPrompt has no agent-context output/);
+    assert.equal(JSON.stringify(existing), before);
+});
+
+for (const host of ['claude', 'codex']) {
+    test(`${host}: setup registers only documented context-loading events`, () => {
+        const configuration = continuityHookConfiguration(host, '/home/jon/.agents/skills/session-continuity/continuity.mjs');
+        const expected = host === 'claude'
+            ? ['UserPromptSubmit', 'UserPromptExpansion', 'SessionStart']
+            : ['UserPromptSubmit', 'SessionStart'];
+        assert.deepEqual(Object.keys(configuration), expected);
+        for (const groups of Object.values(configuration)) {
+            assert.equal(groups.length, 1);
+            assert.equal(groups[0].hooks[0].type, 'command');
+            assert.equal(groups[0].hooks[0].command, `node "/home/jon/.agents/skills/session-continuity/continuity.mjs" hook ${host}`);
+        }
+        assert.equal(new RegExp(configuration.SessionStart[0].matcher).test('compact'), true);
+        if (host === 'claude') {
+            assert.equal(new RegExp(configuration.UserPromptExpansion[0].matcher).test('pstack:poteto-mode'), true);
+            assert.equal(new RegExp(configuration.UserPromptExpansion[0].matcher).test('explain-poteto-mode'), false);
+        }
+    });
+}

package/bin/install.agents-home.test.mjs

@@ -32,6 +32,8 @@ const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
 const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
 const SHIPPED_SKILL_NAME = 'privacy-hygiene';
 const ELI5_SKILL_NAME = 'eli5';
+const E_CODE_REVIEW_SKILL_NAME = 'e-code-review';
+const REFERENCE_DIRECTORY_NAME = 'reference';
 const SHIPPED_AGENT_FILE_NAME = 'clean-coder.md';
 const SHIPPED_AGENT_FILE_NAMES = [
     SHIPPED_AGENT_FILE_NAME,
@@ -69,10 +71,7 @@ const CLEAN_CODER_POLICY_REFERENCES = [
     ],
 ];
 const PERSONAL_SKILL_NAME = 'my-notes';
-const SHARED_DIRECTORY_NAME = '_shared';
-const PR_LOOP_DIRECTORY_NAME = 'pr-loop';
 const PREFLIGHT_PROPOSAL_FILE_NAME = 'preflight-proposal.md';
-const PREFLIGHT_PROPOSAL_POINTER = '@~/.claude/_shared/pr-loop/preflight-proposal.md';
 
 /**
  * @param {string} homeDirectory
@@ -100,20 +99,23 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
 }
 
 /**
- * @param {{ homeDirectory: string, skillsInstallDirectory: string }} installationPaths
+ * @param {{ skillsInstallDirectory: string }} installationPaths
  */
 function assertProposalContractInstallation(installationPaths) {
-    const { homeDirectory, skillsInstallDirectory } = installationPaths;
+    const { skillsInstallDirectory } = installationPaths;
     const allContractPathSegments = [
-        SHARED_DIRECTORY_NAME, PR_LOOP_DIRECTORY_NAME, PREFLIGHT_PROPOSAL_FILE_NAME,
+        E_CODE_REVIEW_SKILL_NAME,
+        REFERENCE_DIRECTORY_NAME,
+        PREFLIGHT_PROPOSAL_FILE_NAME,
     ];
-    const installedPointerPath = join(skillsInstallDirectory, ...allContractPathSegments);
-    const pointerLine = readFileSync(installedPointerPath, 'utf8').trimEnd().split('\n').at(-1);
-    const allTargetSegments = pointerLine.slice('@~/'.length).split('/');
-    const installedContractPath = join(homeDirectory, ...allTargetSegments);
-    const sourceContractPath = join(PACKAGE_DIRECTORY, ...allContractPathSegments);
+    const installedContractPath = join(skillsInstallDirectory, ...allContractPathSegments);
+    const sourceSkillsDirectory = resolvePackageManagedDirectory(
+        PACKAGE_DIRECTORY,
+        MANAGED_SKILLS_DIRECTORY_NAME,
+    );
+    const sourceContractPath = join(sourceSkillsDirectory, ...allContractPathSegments);
 
-    assert.equal(pointerLine, PREFLIGHT_PROPOSAL_POINTER);
+    assert.equal(existsSync(installedContractPath), true);
     assert.equal(readFileSync(installedContractPath, 'utf8'), readFileSync(sourceContractPath, 'utf8'));
 }
 
@@ -197,7 +199,7 @@ test('a full install writes skills and agents under .agents and points .claude a
         );
         assert.equal(realpathSync(lookupSkillFile), realpathSync(canonicalSkillFile));
         assert.equal(realpathSync(lookupEli5SkillFile), realpathSync(canonicalEli5SkillFile));
-        assertProposalContractInstallation({ homeDirectory, skillsInstallDirectory });
+        assertProposalContractInstallation({ skillsInstallDirectory });
         assert.equal(
             readFileSync(lookupAgentFile, 'utf8'),
             readFileSync(canonicalAgentFile, 'utf8'),

package/bin/install.codex-rules.test.mjs

@@ -185,7 +185,7 @@ test('the shipped Codex rules file has no production-scanner home-path findings'
     );
 });
 
-test('--only journal skips Codex rules; --only core copies them', () => {
+test('--only journal is rejected before Codex rules change; --only core copies them', () => {
     const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-codex-groups-'));
     try {
         const installedRulesPath = join(
@@ -194,7 +194,10 @@ test('--only journal skips Codex rules; --only core copies them', () => {
             CODEX_RULES_DIRECTORY_NAME,
             CODEX_RULES_SHIPPED_FILE_NAME,
         );
-        runInstaller(homeDirectory, ['--only', 'journal']);
+        assert.throws(
+            () => runInstaller(homeDirectory, ['--only', 'journal']),
+            error => error.status === 1 && /Unknown group\(s\): journal/.test(error.stderr),
+        );
         assert.equal(existsSync(installedRulesPath), false);
 
         runInstaller(homeDirectory, ['--only', 'core']);

package/bin/install.cursor-rules.test.mjs

@@ -100,7 +100,7 @@ test('a full install writes stem-named Cursor rules and leaves a local extra mdc
     }
 });
 
-test('--only journal skips Cursor rule generation; --only core writes them', () => {
+test('--only journal is rejected before Cursor rules change; --only core writes them', () => {
     const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-cursor-groups-'));
     try {
         const generatedPath = join(
@@ -115,7 +115,10 @@ test('--only journal skips Cursor rule generation; --only core writes them', ()
             'rules',
             'pstack-model-preferences.codex.json',
         );
-        runInstaller(homeDirectory, ['--only', 'journal']);
+        assert.throws(
+            () => runInstaller(homeDirectory, ['--only', 'journal']),
+            error => error.status === 1 && /Unknown group\(s\): journal/.test(error.stderr),
+        );
         assert.equal(existsSync(generatedPath), false);
         assert.equal(existsSync(preferencePath), false);