claude-dev-env 7.6.1 → 7.7.0

package/_shared/advisor/scripts/tests/test_codex_astra_advisor.py

@@ -1,12 +1,13 @@
 """Behavioral tests for the executable Codex Astra advisor path."""
-import io
 import importlib.util
+import io
 import json
 import subprocess
 import sys
 from collections.abc import Callable
 from pathlib import Path
 from types import ModuleType
+
 import pytest
 
 _ProcessRunner = Callable[..., subprocess.CompletedProcess[str]]
@@ -28,6 +29,7 @@ def _load_astra_module() -> ModuleType:
 
 
 astra_advisor = _load_astra_module()
+
 SCRIPTS_ROOT = Path(__file__).parent.parent
 USAGE_PROBE_PATH = (
     SCRIPTS_ROOT.parents[1] / "pr-loop" / "scripts" / "codex_usage_probe.py"
@@ -87,7 +89,37 @@ def test_astra_flag_rejects_legacy_sol_setting() -> None:
 
 def test_resolve_advisor_effort_uses_shared_setting_and_default() -> None:
     assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "HIGH"}) == "high"
-    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "unknown"}) == "low"
+    with pytest.raises(RuntimeError, match="effort is unknown"):
+        astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "unknown"})
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "Light"}) == "low"
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "XHIGH"}) == "medium"
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "MAX"}) == "medium"
+
+
+def test_advisor_route_uses_edited_policy_model_and_effort(tmp_path: Path) -> None:
+    policy = json.loads(
+        (SCRIPTS_ROOT.parents[2] / "rules" / "subagent-model-policy.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    for each_entry in policy["roleReplacements"]:
+        if (
+            each_entry["role"] == "advisor"
+            and each_entry["requested"] == {"model": "astra", "effort": "xhigh"}
+        ):
+            each_entry["selected"] = {"model": "luna", "effort": "high"}
+    policy_path = tmp_path / "subagent-model-policy.json"
+    policy_path.write_text(json.dumps(policy), encoding="utf-8")
+    assert astra_advisor.resolve_advisor_pair(
+        {"ADVISOR_EFFORT": "xhigh"}, policy_path
+    ) == ("gpt-5.6-luna", "high")
+
+
+def test_advisor_route_blocks_malformed_policy(tmp_path: Path) -> None:
+    policy_path = tmp_path / "subagent-model-policy.json"
+    policy_path.write_text('{"schemaVersion": 1}', encoding="utf-8")
+    with pytest.raises(RuntimeError, match="models must be an object"):
+        astra_advisor.resolve_advisor_pair({}, policy_path)
 
 
 def test_resolve_codex_executable_prefers_override_and_falls_back_to_path(
@@ -118,6 +150,7 @@ def test_argument_parser_accepts_astra_and_rejects_sol() -> None:
     parser = astra_advisor.build_argument_parser()
     parsed = parser.parse_args(["--bind", "--cwd", ".", "--enable-astra"])
     assert parsed.is_astra_requested
+    assert parser.parse_args(["--bind", "--cwd", ".", "--effort", "light"]).astra_effort == "light"
     with pytest.raises(SystemExit):
         parser.parse_args(["--bind", "--cwd", ".", "--enable-sol"])
 
@@ -190,6 +223,23 @@ def test_bind_runs_probe_then_codex() -> None:
     assert calls[1] == astra_advisor.build_codex_arguments("codex")
 
 
+def test_bind_routes_astra_xhigh_to_the_policy_effort() -> None:
+    calls: list[list[str]] = []
+    settings = {**ENABLED_SETTINGS, astra_advisor.ADVISOR_EFFORT_ENV_VAR: "xhigh"}
+    reply = astra_advisor.run_codex_astra_advisor(
+        "consult",
+        Path("."),
+        None,
+        USAGE_PROBE_PATH,
+        settings,
+        None,
+        _two_step_runner(calls),
+    )
+    assert reply.successful
+    config_index = calls[1].index("--config")
+    assert calls[1][config_index + 1] == 'model_reasoning_effort="medium"'
+
+
 def test_disabled_flag_returns_declined_fallback() -> None:
     reply = astra_advisor.run_codex_astra_advisor(
         "consult",

package/bin/install-constants.mjs

@@ -56,6 +56,7 @@ export const RUN_BACKUP_DIRECTORY_NAME_PATTERN =
 export const PACKAGE_AGENTS_HOME_DIRECTORY_NAME = '.agents';
 
 export const PSTACK_MODEL_RULE_FILE_NAME = 'pstack-models.mdc';
+export const SUBAGENT_MODEL_POLICY_FILE_NAME = 'subagent-model-policy.json';
 export const PSTACK_SEEDED_MODEL_PREFERENCES_FILE_NAMES = Object.freeze([
     'pstack-model-preferences.claude.json',
     'pstack-model-preferences.codex.json',
@@ -181,3 +182,5 @@ export const WINDOWS_PYTHON_LAUNCHER_COMMAND = 'py -3';
  * Maximum time each Python interpreter probe may run during detection.
  */
 export const PYTHON_PROBE_TIMEOUT_MILLISECONDS = 10_000;
+export const ADDITIONAL_SETTINGS_BLOB_PREFIX = 'settings-';
+export const CODEX_NATIVE_ROUTING_MATCHER = 'multi_agent_v1__spawn_agent';

package/bin/install-transaction.mjs

@@ -30,6 +30,7 @@ import {
 } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { ADDITIONAL_SETTINGS_BLOB_PREFIX } from './install-constants.mjs';
 
 /** Env var that forces a throw after a named mutation phase (tests only). */
 export const INSTALL_FAULT_ENV = 'CLAUDE_DEV_ENV_INSTALL_FAULT';
@@ -180,19 +181,6 @@ function classifyPath(absolutePath, io) {
     return { kind: ENTRY_KIND_MISSING };
 }
 
-/**
- * Capture prior settings, manifest, hooksPath, and package-owned files.
- *
- * @param {{
- *   managedRoot: string,
- *   manifestFilePath: string,
- *   settingsPath: string,
- *   priorManifestFiles?: string[]|null,
- *   journalParentDirectory?: string,
- *   io?: object,
- * }} input
- * @returns {object}
- */
 export function capturePriorInstallSnapshot(input) {
     const io = input.io || {};
     const exists = io.existsSync || existsSync;
@@ -208,10 +196,23 @@ export function capturePriorInstallSnapshot(input) {
     const filesDirectory = join(journalRoot, FILES_DIRECTORY_NAME);
     mkdir(filesDirectory, { recursive: true });
 
-    const settingsExisted = exists(input.settingsPath);
-    if (settingsExisted) {
-        copyFile(input.settingsPath, join(journalRoot, SETTINGS_BLOB_NAME));
-    }
+    const allSettingsPaths = [
+        input.settingsPath,
+        ...(Array.isArray(input.additionalSettingsPaths) ? input.additionalSettingsPaths : []),
+    ].filter((eachPath, index, allPaths) => (
+        typeof eachPath === 'string'
+        && eachPath !== ''
+        && allPaths.indexOf(eachPath) === index
+    ));
+    const settingsSnapshots = allSettingsPaths.map((settingsPath, index) => {
+        const settingsExisted = exists(settingsPath);
+        const blobName = index === 0
+            ? SETTINGS_BLOB_NAME
+            : `${ADDITIONAL_SETTINGS_BLOB_PREFIX}${index}.json`;
+        if (settingsExisted) copyFile(settingsPath, join(journalRoot, blobName));
+        return { path: settingsPath, existed: settingsExisted, blobName };
+    });
+    const primarySettingsSnapshot = settingsSnapshots[0];
 
     const manifestExisted = exists(input.manifestFilePath);
     if (manifestExisted) {
@@ -255,7 +256,8 @@ export function capturePriorInstallSnapshot(input) {
         managedRoot: input.managedRoot,
         settingsPath: input.settingsPath,
         manifestFilePath: input.manifestFilePath,
-        settingsExisted,
+        settingsSnapshots,
+        settingsExisted: primarySettingsSnapshot?.existed ?? false,
         manifestExisted,
         priorHooksPath,
         allFileEntries,
@@ -267,23 +269,14 @@ export function capturePriorInstallSnapshot(input) {
         managedRoot: input.managedRoot,
         settingsPath: input.settingsPath,
         manifestFilePath: input.manifestFilePath,
-        settingsExisted,
+        settingsSnapshots: Object.freeze(settingsSnapshots.map(eachSnapshot => Object.freeze(eachSnapshot))),
+        settingsExisted: primarySettingsSnapshot?.existed ?? false,
         manifestExisted,
         priorHooksPath,
         allFileEntries: Object.freeze(allFileEntries.map((eachEntry) => Object.freeze({ ...eachEntry }))),
     });
 }
 
-/**
- * Restore the captured prior installation and drop extra write-set paths.
- *
- * @param {ReturnType<typeof capturePriorInstallSnapshot>} snapshot
- * @param {{
- *   allWrittenPaths?: string[],
- *   io?: object,
- * }} [options]
- * @returns {void}
- */
 export function restorePriorInstallSnapshot(snapshot, options = {}) {
     const io = options.io || {};
     const exists = io.existsSync || existsSync;
@@ -294,6 +287,13 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
     const lstat = io.lstatSync || lstatSync;
 
     const filesDirectory = join(snapshot.journalRoot, FILES_DIRECTORY_NAME);
+    const settingsSnapshots = snapshot.settingsSnapshots?.length > 0
+        ? snapshot.settingsSnapshots
+        : [{
+            path: snapshot.settingsPath,
+            existed: snapshot.settingsExisted,
+            blobName: SETTINGS_BLOB_NAME,
+        }];
     for (const eachEntry of snapshot.allFileEntries) {
         try {
             if (exists(eachEntry.absolutePath)) {
@@ -302,9 +302,7 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
                     unlink(eachEntry.absolutePath);
                 }
             }
-        } catch {
-            // keep restoring remaining entries
-        }
+        } catch {}
         if (eachEntry.kind === ENTRY_KIND_FILE && eachEntry.blobName) {
             mkdir(dirname(eachEntry.absolutePath), { recursive: true });
             copyFile(join(filesDirectory, eachEntry.blobName), eachEntry.absolutePath);
@@ -324,7 +322,8 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
         if (priorPathSet.has(eachWrittenPath)) {
             continue;
         }
-        if (eachWrittenPath === snapshot.settingsPath || eachWrittenPath === snapshot.manifestFilePath) {
+        if (settingsSnapshots.some(eachSnapshot => eachSnapshot.path === eachWrittenPath)
+            || eachWrittenPath === snapshot.manifestFilePath) {
             continue;
         }
         try {
@@ -339,14 +338,14 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
         }
     }
 
-    if (snapshot.settingsExisted) {
-        mkdir(dirname(snapshot.settingsPath), { recursive: true });
-        copyFile(join(snapshot.journalRoot, SETTINGS_BLOB_NAME), snapshot.settingsPath);
-    } else if (exists(snapshot.settingsPath)) {
-        try {
-            unlink(snapshot.settingsPath);
-        } catch {
-            // leave in place when unlink fails
+    for (const eachSnapshot of settingsSnapshots) {
+        if (eachSnapshot.existed) {
+            mkdir(dirname(eachSnapshot.path), { recursive: true });
+            copyFile(join(snapshot.journalRoot, eachSnapshot.blobName), eachSnapshot.path);
+        } else if (exists(eachSnapshot.path)) {
+            try {
+                unlink(eachSnapshot.path);
+            } catch {}
         }
     }
 
@@ -356,9 +355,7 @@ export function restorePriorInstallSnapshot(snapshot, options = {}) {
     } else if (exists(snapshot.manifestFilePath)) {
         try {
             unlink(snapshot.manifestFilePath);
-        } catch {
-            // leave in place when unlink fails
-        }
+        } catch {}
     }
 
     writeGlobalCoreHooksPath(snapshot.priorHooksPath, io);

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

@@ -6,6 +6,7 @@ import {
     writeFileSync,
     readFileSync,
     existsSync,
+    copyFileSync,
     rmSync,
 } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -150,6 +151,11 @@ for (const targetName of [null, 'profile']) {
                 'rules',
                 'pstack-model-preferences.codex.json',
             );
+            const policyPath = join(
+                resolution.agentsHome,
+                'rules',
+                'subagent-model-policy.json',
+            );
             const selectorPath = join(
                 resolution.agentsHome,
                 'scripts',
@@ -172,10 +178,12 @@ for (const targetName of [null, 'profile']) {
             assert.equal(readFileSync(cursorPath, 'utf8'), installedText);
             assert.equal(isAllowedInstallDestination(sharedPath, resolution), true);
             assert.equal(existsSync(selectorPath), true);
+            assert.equal(existsSync(policyPath), true);
 
             const savedPreferences = JSON.parse(readFileSync(preferencesPath, 'utf8'));
             assert.deepEqual(savedPreferences, {
                 host: 'codex',
+                defaultEffort: 'medium',
                 modelsByRole: {
                     'feature, refactoring': ['gpt-5.6-sol'],
                     'bug-fix': ['gpt-5.6-sol'],
@@ -216,9 +224,9 @@ for (const targetName of [null, 'profile']) {
                     hasMaterialCapabilityLoss: false,
                 },
             });
-            assert.deepEqual(codexSelection.nativeSpawnArguments, {
-                model: 'gpt-5.6-sol',
-            });
+            assert.equal(codexSelection.canDelegate, false);
+            assert.equal(codexSelection.failure, 'no-supported-model');
+            assert.deepEqual(codexSelection.nativeSpawnArguments, {});
 
             const claudePreferencesPath = join(
                 resolution.agentsHome,
@@ -344,6 +352,306 @@ for (const targetName of [null, 'profile']) {
     });
 }
 
+test('seeds one editable policy and one native Codex routing hook', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-install-'));
+    try {
+        const resolution = resolveInstallRoot({
+            homeDirectory,
+            environment: {},
+            explicitTarget: null,
+        });
+        const policyPath = join(resolution.agentsHome, 'rules', 'subagent-model-policy.json');
+        const installedRulesPolicyPath = join(
+            resolution.managedRoot,
+            'rules',
+            'subagent-model-policy.json',
+        );
+        const codexHooksPath = join(homeDirectory, '.codex', 'hooks.json');
+
+        runInstaller(homeDirectory, ['--only', 'core']);
+
+        assert.equal(existsSync(policyPath), true);
+        assert.equal(existsSync(installedRulesPolicyPath), false);
+        const firstCodexHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
+        const firstRoutingGroups = firstCodexHooks.hooks.PreToolUse.filter(
+            group => group.matcher === 'multi_agent_v1__spawn_agent',
+        );
+        assert.equal(firstRoutingGroups.length, 1);
+        assert.equal(firstRoutingGroups[0].hooks.length, 1);
+        assert.match(firstRoutingGroups[0].hooks[0].command, /subagent_model_routing\.mjs/);
+        assert.equal(
+            firstCodexHooks.hooks.PreToolUse.some(group => group.matcher === 'Write|Edit|MultiEdit|apply_patch'),
+            false,
+        );
+
+        const editedPolicy = '{"schemaVersion":1,"edited":true}\n';
+        writeFileSync(policyPath, editedPolicy);
+        firstCodexHooks.hooks.PreToolUse.push({
+            matcher: 'custom',
+            hooks: [{ type: 'command', command: 'python user-hook.py' }],
+        });
+        writeFileSync(codexHooksPath, JSON.stringify(firstCodexHooks, null, 2) + '\n');
+
+        runInstaller(homeDirectory, ['--only', 'core']);
+
+        assert.equal(readFileSync(policyPath, 'utf8'), editedPolicy);
+        const secondCodexHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
+        assert.equal(
+            secondCodexHooks.hooks.PreToolUse.filter(
+                group => group.matcher === 'multi_agent_v1__spawn_agent',
+            ).length,
+            1,
+        );
+        assert.equal(
+            secondCodexHooks.hooks.PreToolUse.some(
+                group => group.matcher === 'custom'
+                    && group.hooks.some(hook => hook.command === 'python user-hook.py'),
+            ),
+            true,
+        );
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('reinstall moves the old routing hook and keeps user hooks', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-hook-upgrade-'));
+    try {
+        const resolution = resolveInstallRoot({
+            homeDirectory,
+            environment: {},
+            explicitTarget: null,
+        });
+        const codexHooksPath = join(homeDirectory, '.codex', 'hooks.json');
+        const manifestPath = resolution.manifestFilePath;
+        const routingHookPath = join(
+            homeDirectory,
+            '.codex',
+            'hooks',
+            'routing',
+            'subagent_model_routing.mjs',
+        );
+        const oldRoutingHookPath = join(
+            homeDirectory,
+            '.codex',
+            'hooks',
+            'blocking',
+            'subagent_model_routing.mjs',
+        );
+
+        runInstaller(homeDirectory, []);
+        const firstCodexHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
+        const firstRoutingGroup = firstCodexHooks.hooks.PreToolUse.find(
+            group => group.matcher === 'multi_agent_v1__spawn_agent',
+        );
+        firstRoutingGroup.hooks[0].command = firstRoutingGroup.hooks[0].command.replace(
+            /routing([\\/])subagent_model_routing\.mjs$/,
+            'blocking$1subagent_model_routing.mjs',
+        );
+        firstCodexHooks.hooks.PreToolUse.push({
+            matcher: 'custom',
+            hooks: [{ type: 'command', command: 'node user-hook.mjs' }],
+        });
+        writeFileSync(codexHooksPath, JSON.stringify(firstCodexHooks, null, 2) + '\n');
+        copyFileSync(routingHookPath, oldRoutingHookPath);
+        rmSync(routingHookPath);
+
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        manifest.files = manifest.files.map(file => file.replace(
+            /([\\/])routing([\\/]subagent_model_routing\.mjs)$/,
+            '$1blocking$2',
+        ));
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+
+        runInstaller(homeDirectory, []);
+
+        const secondCodexHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
+        const routingGroups = secondCodexHooks.hooks.PreToolUse.filter(
+            group => group.matcher === 'multi_agent_v1__spawn_agent',
+        );
+        assert.equal(routingGroups.length, 1);
+        assert.match(routingGroups[0].hooks[0].command, /[\\/]hooks[\\/]routing[\\/]subagent_model_routing\.mjs/);
+        assert.doesNotMatch(
+            JSON.stringify(secondCodexHooks),
+            /[\\/]hooks[\\/]blocking[\\/]subagent_model_routing\.mjs/,
+        );
+        assert.equal(existsSync(routingHookPath), true);
+        assert.equal(existsSync(oldRoutingHookPath), false);
+        assert.equal(
+            secondCodexHooks.hooks.PreToolUse.some(
+                group => group.matcher === 'custom'
+                    && group.hooks.some(hook => hook.command === 'node user-hook.mjs'),
+            ),
+            true,
+        );
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('uninstall removes the routing hook and keeps a Codex user hook', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-uninstall-'));
+    try {
+        const profileRoot = join(homeDirectory, 'named-profile');
+        const codexHooksPath = join(profileRoot, '.codex', 'hooks.json');
+        const targetArguments = ['--target', profileRoot];
+        runInstaller(homeDirectory, [...targetArguments, '--only', 'core']);
+        const codexHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
+        codexHooks.hooks.PreToolUse.push({
+            matcher: 'custom',
+            hooks: [{ type: 'command', command: 'python user-hook.py' }],
+        });
+        writeFileSync(codexHooksPath, JSON.stringify(codexHooks, null, 2) + '\n');
+
+        runInstaller(homeDirectory, [...targetArguments, '--uninstall']);
+
+        const remainingHooks = JSON.parse(readFileSync(codexHooksPath, 'utf8'));
+        assert.equal(
+            remainingHooks.hooks.PreToolUse.some(group => group.matcher === 'multi_agent_v1__spawn_agent'),
+            false,
+        );
+        assert.equal(
+            remainingHooks.hooks.PreToolUse.some(
+                group => group.matcher === 'custom'
+                    && group.hooks.some(hook => hook.command === 'python user-hook.py'),
+            ),
+            true,
+        );
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('malformed Codex hooks restore the staged install', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-malformed-'));
+    try {
+        const codexHooksPath = join(homeDirectory, '.codex', 'hooks.json');
+        const claudeSettingsPath = join(homeDirectory, '.claude', 'settings.json');
+        const originalCodexHooks = '{ malformed\n';
+        const originalClaudeSettings = '{"hooks":{"PreToolUse":[{"matcher":"user","hooks":[{"type":"command","command":"user-hook"}]}]}}\n';
+        mkdirSync(dirname(codexHooksPath), { recursive: true });
+        mkdirSync(dirname(claudeSettingsPath), { recursive: true });
+        writeFileSync(codexHooksPath, originalCodexHooks);
+        writeFileSync(claudeSettingsPath, originalClaudeSettings);
+
+        assert.throws(
+            () => runInstaller(homeDirectory, ['--only', 'core']),
+            error => error.status === 1,
+        );
+        assert.equal(readFileSync(codexHooksPath, 'utf8'), originalCodexHooks);
+        assert.equal(readFileSync(claudeSettingsPath, 'utf8'), originalClaudeSettings);
+        assert.equal(existsSync(join(homeDirectory, '.claude', 'hooks')), false);
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('malformed Codex hooks restore an uninstall', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-uninstall-malformed-'));
+    try {
+        runInstaller(homeDirectory, ['--only', 'core']);
+        const codexHooksPath = join(homeDirectory, '.codex', 'hooks.json');
+        const manifestPath = join(homeDirectory, '.claude', '.claude-dev-env-manifest.json');
+        const managedHookPath = join(
+            homeDirectory,
+            '.claude',
+            'hooks',
+            'routing',
+            'subagent_model_routing.mjs',
+        );
+        writeFileSync(codexHooksPath, '{ malformed\n');
+
+        assert.throws(
+            () => runInstaller(homeDirectory, ['--uninstall']),
+            error => error.status === 1,
+        );
+        assert.equal(existsSync(manifestPath), true);
+        assert.equal(existsSync(managedHookPath), true);
+        assert.equal(readFileSync(codexHooksPath, 'utf8'), '{ malformed\n');
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('two profiles keep separate Codex routing hooks', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-profiles-'));
+    try {
+        const profileRoot = join(homeDirectory, 'named-profile');
+        const mainCodexHooksPath = join(homeDirectory, '.codex', 'hooks.json');
+        const profileCodexHooksPath = join(profileRoot, '.codex', 'hooks.json');
+        runInstaller(homeDirectory, ['--only', 'core']);
+        runInstaller(homeDirectory, ['--target', profileRoot, '--only', 'core']);
+
+        const mainCodexHooks = JSON.parse(readFileSync(mainCodexHooksPath, 'utf8'));
+        const profileCodexHooks = JSON.parse(readFileSync(profileCodexHooksPath, 'utf8'));
+        const mainRoutingGroups = (mainCodexHooks.hooks?.PreToolUse ?? []).filter(
+            group => group.matcher === 'multi_agent_v1__spawn_agent',
+        );
+        const profileRoutingGroups = profileCodexHooks.hooks.PreToolUse.filter(
+            group => group.matcher === 'multi_agent_v1__spawn_agent',
+        );
+        assert.equal(mainRoutingGroups.length, 1);
+        assert.equal(profileRoutingGroups.length, 1);
+        assert.match(mainRoutingGroups[0].hooks[0].command, /[\\/]\.codex[\\/]hooks[\\/]routing[\\/]subagent_model_routing\.mjs/);
+        assert.match(profileRoutingGroups[0].hooks[0].command, /named-profile[\\/]\.codex[\\/]hooks[\\/]routing[\\/]subagent_model_routing\.mjs/);
+        assert.notEqual(mainRoutingGroups[0].hooks[0].command, profileRoutingGroups[0].hooks[0].command);
+
+        const profileHookPath = join(
+            profileRoot,
+            '.codex',
+            'hooks',
+            'routing',
+            'subagent_model_routing.mjs',
+        );
+        const profileHookResponse = JSON.parse(execFileSync(
+            'node',
+            [profileHookPath],
+            {
+                encoding: 'utf8',
+                input: JSON.stringify({
+                    tool_name: 'multi_agent_v1__spawn_agent',
+                    tool_input: { model: 'Terra', reasoning_effort: 'medium' },
+                }),
+            },
+        ));
+        assert.equal(
+            profileHookResponse.hookSpecificOutput.updatedInput.model,
+            'gpt-5.6-luna',
+        );
+        assert.equal(
+            profileHookResponse.hookSpecificOutput.updatedInput.reasoning_effort,
+            'xhigh',
+        );
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
+test('uninstalling one profile keeps routing for another installed profile', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-routing-profile-uninstall-'));
+    try {
+        const profileRoot = join(homeDirectory, 'named-profile');
+        const mainCodexHooksPath = join(homeDirectory, '.codex', 'hooks.json');
+        const profileCodexHooksPath = join(profileRoot, '.codex', 'hooks.json');
+        runInstaller(homeDirectory, ['--only', 'core']);
+        runInstaller(homeDirectory, ['--target', profileRoot, '--only', 'core']);
+        runInstaller(homeDirectory, ['--uninstall']);
+
+        const mainCodexHooks = JSON.parse(readFileSync(mainCodexHooksPath, 'utf8'));
+        const profileCodexHooks = JSON.parse(readFileSync(profileCodexHooksPath, 'utf8'));
+        const mainRoutingGroups = (mainCodexHooks.hooks?.PreToolUse ?? []).filter(
+            group => group.matcher === 'multi_agent_v1__spawn_agent',
+        );
+        const profileRoutingGroups = profileCodexHooks.hooks.PreToolUse.filter(
+            group => group.matcher === 'multi_agent_v1__spawn_agent',
+        );
+        assert.equal(mainRoutingGroups.length, 0);
+        assert.equal(profileRoutingGroups.length, 1);
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});
+
 test('a blocked shared rule destination rolls back generated Cursor files', () => {
     const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-pstack-rollback-'));
     try {