claude-dev-env 7.6.0 → 7.7.0

package/bin/pstack-model-preferences.codex.json

@@ -1,5 +1,6 @@
 {
     "host": "codex",
+    "defaultEffort": "medium",
     "modelsByRole": {
         "feature, refactoring": ["gpt-5.6-sol"],
         "bug-fix": ["gpt-5.6-sol"],

package/bin/pstack.mjs

@@ -67,6 +67,9 @@ function adapterFiles(root) {
         ...['common.md', ...hosts.map(host => `host-${host}.md`), 'create-skill.md'].map(name => [name, join(adapters, name)]),
         ...['pstack-host-mapping.md', 'pstack-models.md'].map(name => [name, join(root, 'rules', name)]),
         ['select_pstack_models.mjs', join(root, 'scripts', 'select_pstack_models.mjs')],
+        ['subagent_model_policy.mjs', join(root, 'scripts', 'subagent_model_policy.mjs')],
+        ['resolve_advisor_model_route.mjs', join(root, 'scripts', 'resolve_advisor_model_route.mjs')],
+        ['subagent-model-policy.json', join(root, 'rules', 'subagent-model-policy.json')],
     ].map(([name, path]) => [name, readFileSync(path, 'utf8')]));
 }
 
@@ -141,7 +144,7 @@ export function prepareRelease(checkout, stage, finalRoot, lock, adapters) {
     const fileDigests = Object.fromEntries(filesUnder(stage).map(path => [relative(stage, path), digest(readFileSync(path))]));
     const managedRoot = dirname(dirname(dirname(finalRoot)));
     const agentsRoot = basename(managedRoot) === '.claude' ? join(dirname(managedRoot), '.agents') : managedRoot + '.agents';
-    const release = { preferencesDirectory: join(agentsRoot, 'rules'), selectorPath: join(finalRoot, 'compat', 'select_pstack_models.mjs'), schemaVersion: 1, commit: lock.commit, adapterVersion: lock.adapterVersion, skills, agents, fileDigests, verification: 'filesystem-only' };
+    const release = { preferencesDirectory: join(agentsRoot, 'rules'), policyPath: join(agentsRoot, 'rules', 'subagent-model-policy.json'), selectorPath: join(finalRoot, 'compat', 'select_pstack_models.mjs'), schemaVersion: 1, commit: lock.commit, adapterVersion: lock.adapterVersion, skills, agents, fileDigests, verification: 'filesystem-only' };
     writeFileSync(join(stage, 'release.json'), json(release));
     return release;
 }
@@ -171,7 +174,7 @@ export function verifyRelease(root) {
 function layout(options) {
     const root = resolve(options.root ?? (options.project ? join(options.project, '.claude') : process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude')));
     const agents = basename(root) === '.claude' ? join(dirname(root), '.agents') : root + '.agents';
-    return { root, store: join(root, 'pstack'), skillHomes: [join(root, 'skills'), join(agents, 'skills')] };
+    return { root, agents, store: join(root, 'pstack'), skillHomes: [join(root, 'skills'), join(agents, 'skills')] };
 }
 
 function loadState(store) {
@@ -224,6 +227,19 @@ function publish(releaseRoot, release, homes, prior) {
     return { links, restore };
 }
 
+function seedPolicy(releaseRoot, release, agentsRoot) {
+    const policyPath = join(agentsRoot, 'rules', 'subagent-model-policy.json');
+    if (typeof release.policyPath !== 'string') throw new Error('Invalid release policy path');
+    if (resolve(release.policyPath) !== resolve(policyPath)) throw new Error('Invalid release policy path');
+    mkdirSync(dirname(policyPath), { recursive: true });
+    if (entryExists(policyPath)) {
+        if (!lstatSync(policyPath).isFile()) throw new Error(`Keep existing unmanaged policy path: ${policyPath}`);
+        return () => {};
+    }
+    writeFileSync(policyPath, readFileSync(join(releaseRoot, 'compat', 'subagent-model-policy.json')), { flag: 'wx' });
+    return () => { if (entryExists(policyPath)) unlinkSync(policyPath); };
+}
+
 function liveLeases(store) {
     const root = join(store, 'sessions');
     if (!existsSync(root)) return false;
@@ -247,7 +263,7 @@ function readCentralLock(temporaryRoot) {
 }
 
 export function installPstack(options = {}, dependencies = {}) {
-    const { store, skillHomes } = layout(options);
+    const { agents, store, skillHomes } = layout(options);
     mkdirSync(store, { recursive: true });
     const lockDirectory = join(store, '.install-lock');
     mkdirSync(lockDirectory);
@@ -291,12 +307,18 @@ export function installPstack(options = {}, dependencies = {}) {
             renameSync(stage, releaseRoot);
         }
         const release = verifyRelease(releaseRoot);
-        const publication = publish(releaseRoot, release, skillHomes, prior);
-        const state = { release: id, commit: lock.commit, adapterVersion: lock.adapterVersion, adapterDigest, checkedAt, lock, links: publication.links };
+        const policyPublication = seedPolicy(releaseRoot, release, agents);
+        let publication;
         try {
+            publication = publish(releaseRoot, release, skillHomes, prior);
+            const state = { release: id, commit: lock.commit, adapterVersion: lock.adapterVersion, adapterDigest, checkedAt, lock, links: publication.links };
             writeFileSync(join(store, 'installed.next.json'), json(state));
             renameSync(join(store, 'installed.next.json'), join(store, 'installed.json'));
-        } catch (error) { publication.restore(); throw error; }
+        } catch (error) {
+            publication?.restore();
+            policyPublication();
+            throw error;
+        }
         return finish({ ...verifyInstallation(options), status: prior?.release === id ? 'unchanged' : 'installed' });
     } catch (error) {
         if (!options.strict) {

package/bin/pstack.test.mjs

@@ -46,6 +46,26 @@ for (const host of ['claude', 'codex', 'cursor']) {
         const release = join(f.store, 'releases', result.release);
         const releaseManifest = JSON.parse(readFileSync(join(release, 'release.json'), 'utf8'));
         assert.equal(releaseManifest.skills.find(skill => skill.component === 'pstack').name, 'pstack:poteto-mode');
+        assert.equal(
+            releaseManifest.policyPath,
+            join(f.options.project, '.agents', 'rules', 'subagent-model-policy.json'),
+        );
+        assert.equal(
+            readFileSync(join(release, 'compat', 'subagent_model_policy.mjs'), 'utf8'),
+            readFileSync(join(packageRoot, 'scripts', 'subagent_model_policy.mjs'), 'utf8'),
+        );
+        assert.equal(
+            readFileSync(join(release, 'compat', 'subagent-model-policy.json'), 'utf8'),
+            readFileSync(join(packageRoot, 'rules', 'subagent-model-policy.json'), 'utf8'),
+        );
+        assert.equal(
+            readFileSync(join(release, 'compat', 'resolve_advisor_model_route.mjs'), 'utf8'),
+            readFileSync(join(packageRoot, 'scripts', 'resolve_advisor_model_route.mjs'), 'utf8'),
+        );
+        assert.equal(
+            readFileSync(join(f.options.project, '.agents', 'rules', 'subagent-model-policy.json'), 'utf8'),
+            readFileSync(join(packageRoot, 'rules', 'subagent-model-policy.json'), 'utf8'),
+        );
         const expected = ['cde-create-skill', 'cursor-team-kit-control-cli', 'cursor-team-kit-control-ui', 'cursor-team-kit-deslop', 'pstack'];
         for (const home of ['.claude', '.agents']) {
             const skillsHome = join(f.options.project, home, 'skills');
@@ -85,6 +105,34 @@ test('unchanged install avoids another upstream fetch', t => {
     assert.deepEqual(second.links, first.links);
 });
 
+test('policy edits survive a pstack update', t => {
+    const f = fixture(t);
+    installPstack(f.options, f.dependencies);
+    const policyPath = join(f.options.project, '.agents', 'rules', 'subagent-model-policy.json');
+    const editedPolicy = '{"schemaVersion":1,"edited":true}\n';
+    writeFileSync(policyPath, editedPolicy);
+    installPstack({ ...f.options, lock: { ...baseLock, commit: 'b'.repeat(40) } }, f.dependencies);
+    assert.equal(readFileSync(policyPath, 'utf8'), editedPolicy);
+});
+
+test('a release cannot redirect the installed policy path', t => {
+    const f = fixture(t);
+    const first = installPstack(f.options, f.dependencies);
+    const releaseRoot = join(f.store, 'releases', first.release);
+    const releaseManifestPath = join(releaseRoot, 'release.json');
+    const releaseManifest = JSON.parse(readFileSync(releaseManifestPath, 'utf8'));
+    const outsidePolicyPath = join(f.temporary, 'outside-policy.json');
+    releaseManifest.policyPath = outsidePolicyPath;
+    writeFileSync(releaseManifestPath, JSON.stringify(releaseManifest));
+
+    assert.throws(
+        () => installPstack({ ...f.options, strict: true }, f.dependencies),
+        /Invalid release policy path/,
+    );
+    assert.equal(existsSync(outsidePolicyPath), false);
+    assert.equal(verifyInstallation(f.options).release, first.release);
+});
+
 test('changed, added, and removed skills converge while old releases remain readable', t => {
     const f = fixture(t);
     put(join(f.checkout, 'pstack', 'skills', 'old', 'SKILL.md'), '---\nname: old\ndescription: Old skill.\n---\nOld body.\n');

package/bin/select-pstack-models.test.mjs

@@ -1,8 +1,9 @@
 import { test } from 'node:test';
 import { strict as assert } from 'node:assert';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { defaultSubagentModelPolicyPath } from '../scripts/subagent_model_policy.mjs';
 import {
     allPstackRoleRequirements,
     selectPstackDelegation,
@@ -29,14 +30,27 @@ const ALL_PSTACK_ROLES = [
     'interrogate reviewers',
 ];
 
-function writeHostPreferences(preferencesDirectory, host, modelsByRole) {
+function writeHostPreferences(preferencesDirectory, host, modelsByRole, defaultEffort) {
     mkdirSync(preferencesDirectory, { recursive: true });
+    const preferences = { host, modelsByRole };
+    if (defaultEffort !== undefined) preferences.defaultEffort = defaultEffort;
     writeFileSync(
         join(preferencesDirectory, 'pstack-model-preferences.' + host + '.json'),
-        JSON.stringify({ host, modelsByRole }),
+        JSON.stringify(preferences),
     );
 }
 
+function writePolicyWithModels(preferencesDirectory, modelEntries) {
+    const policy = JSON.parse(readFileSync(defaultSubagentModelPolicyPath(), 'utf8'));
+    for (const [name, id] of Object.entries(modelEntries)) {
+        policy.models[name] = { id, aliases: [] };
+        policy.approvedPairs.push({ model: name, effort: 'medium' });
+    }
+    const policyPath = join(preferencesDirectory, 'subagent-model-policy.json');
+    writeFileSync(policyPath, JSON.stringify(policy));
+    return policyPath;
+}
+
 function selectWithPreferences(preferencesDirectory, overrides) {
     return selectPstackDelegation({
         host: 'codex',
@@ -49,6 +63,7 @@ function selectWithPreferences(preferencesDirectory, overrides) {
             isAllowed: false,
             hasMaterialCapabilityLoss: false,
         },
+        requestedEffort: 'medium',
         preferencesDirectory,
         ...overrides,
     });
@@ -60,7 +75,7 @@ test('portable policy represents every pstack role without model ids', () => {
     assert.doesNotMatch(serializedRequirements, /gpt-|claude-|grok-/i);
 });
 
-test('Codex preferences select every available model in a diverse panel', () => {
+test('Codex preferences skip an excluded pair in a panel', () => {
     const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-codex-'));
     try {
         writeHostPreferences(preferencesDirectory, 'codex', {
@@ -69,18 +84,26 @@ test('Codex preferences select every available model in a diverse panel', () =>
         const selection = selectWithPreferences(preferencesDirectory, {
             role: 'how critics',
             delegationIndex: 1,
-            availableModelIds: ['gpt-5.6-sol', 'gpt-6-astra', 'gpt-5.6-terra'],
+            availableModelIds: [
+                'gpt-5.6-sol',
+                'gpt-6-astra',
+                'gpt-5.6-terra',
+                'gpt-5.6-luna',
+            ],
         });
         assert.equal(selection.canDelegate, true);
         assert.equal(selection.selectedHost, 'codex');
         assert.equal(selection.selectionSource, 'host-preference');
         assert.deepEqual(selection.panel.selectedModelIds, [
-            'gpt-5.6-terra',
-            'gpt-5.6-sol',
+            'gpt-5.6-luna',
             'gpt-6-astra',
+            'gpt-5.6-luna',
         ]);
-        assert.equal(selection.panel.isCrossModelDiverse, true);
-        assert.deepEqual(selection.nativeSpawnArguments, { model: 'gpt-5.6-sol' });
+        assert.equal(selection.panel.isCrossModelDiverse, false);
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-6-astra',
+            reasoning_effort: 'medium',
+        });
         assert.equal(selection.omitNativeModelArgument, false);
         assert.equal(selection.availabilityValidated, true);
     } finally {
@@ -111,21 +134,23 @@ test('a foreign host reads only its own saved preferences', () => {
     }
 });
 
-test('an unavailable preferred model uses a confirmed host alternative', () => {
+test('an unavailable preferred model stops before a confirmed host alternative', () => {
     const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-alternative-'));
     try {
         writeHostPreferences(preferencesDirectory, 'codex', {
-            'feature, refactoring': ['gpt-5.6-sol'],
+            'feature, refactoring': ['gpt-5.6-terra'],
+        });
+        const policyPath = writePolicyWithModels(preferencesDirectory, {
+            current: 'confirmed-current-model',
         });
         const selection = selectWithPreferences(preferencesDirectory, {
             availableModelIds: ['confirmed-current-model'],
             confirmedSuitableModelIds: ['confirmed-current-model'],
+            policyPath,
         });
-        assert.equal(selection.canDelegate, true);
-        assert.equal(selection.selectionSource, 'confirmed-host-alternative');
-        assert.deepEqual(selection.nativeSpawnArguments, {
-            model: 'confirmed-current-model',
-        });
+        assert.equal(selection.canDelegate, false);
+        assert.match(selection.failure, /model-routing-failed: replacement model is unavailable/);
+        assert.deepEqual(selection.nativeSpawnArguments, {});
     } finally {
         rmSync(preferencesDirectory, { recursive: true, force: true });
     }
@@ -143,7 +168,10 @@ test('the arena cross-judge pool selects one model other than the parent', () =>
             availableModelIds: ['gpt-5.6-sol', 'gpt-6-astra'],
         });
         assert.equal(selection.panel.agentCount, 1);
-        assert.deepEqual(selection.nativeSpawnArguments, { model: 'gpt-6-astra' });
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-6-astra',
+            reasoning_effort: 'medium',
+        });
     } finally {
         rmSync(preferencesDirectory, { recursive: true, force: true });
     }
@@ -154,6 +182,9 @@ test('the arena cross-judge prefers a real alternative over parent inheritance',
         writeHostPreferences(preferencesDirectory, 'codex', {
             'arena cross-judge pool': ['auto', 'confirmed-other-model'],
         });
+        const policyPath = writePolicyWithModels(preferencesDirectory, {
+            other: 'confirmed-other-model',
+        });
         const selection = selectWithPreferences(preferencesDirectory, {
             role: 'arena cross-judge pool',
             parentModelId: 'current-parent-model',
@@ -162,9 +193,11 @@ test('the arena cross-judge prefers a real alternative over parent inheritance',
                 isAllowed: true,
                 hasMaterialCapabilityLoss: false,
             },
+            policyPath,
         });
         assert.deepEqual(selection.nativeSpawnArguments, {
             model: 'confirmed-other-model',
+            reasoning_effort: 'medium',
         });
         assert.equal(selection.omitNativeModelArgument, false);
     } finally {
@@ -196,13 +229,16 @@ test('a same-model swarm reports its actual panel composition', () => {
             'gpt-5.6-luna',
         ]);
         assert.equal(selection.panel.isCrossModelDiverse, false);
-        assert.deepEqual(selection.nativeSpawnArguments, { model: 'gpt-5.6-luna' });
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-5.6-luna',
+            reasoning_effort: 'high',
+        });
     } finally {
         rmSync(preferencesDirectory, { recursive: true, force: true });
     }
 });
 
-test('a diversity-required panel fails without enough distinct real models', () => {
+test('a diversity-required panel fails without enough distinct models', () => {
     const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-diversity-'));
     try {
         writeHostPreferences(preferencesDirectory, 'codex', {
@@ -214,7 +250,7 @@ test('a diversity-required panel fails without enough distinct real models', ()
         });
         assert.equal(selection.canDelegate, false);
         assert.equal(selection.requiresUserChoice, true);
-        assert.equal(selection.failure, 'distinct-models-unavailable');
+        assert.match(selection.failure, /model-routing-failed:/);
         assert.equal(selection.panel.isCrossModelDiverse, false);
         assert.deepEqual(selection.nativeSpawnArguments, {});
     } finally {
@@ -244,6 +280,63 @@ test('parent inheritance omits the native model argument', () => {
     }
 });
 
+test('parent inheritance rejects an explicit preference effort', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-parent-effort-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': [{ model: 'auto', effort: 'medium' }],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            availableModelIds: [],
+            parentFallback: {
+                isAllowed: true,
+                hasMaterialCapabilityLoss: false,
+            },
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.equal(selection.failure, 'model-routing-failed: parent inheritance cannot set an effort');
+        assert.deepEqual(selection.panel.selectedModelIds, []);
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('selector rejects policy-defined inheritance aliases in model inventories', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-inventory-alias-'));
+    try {
+        assert.throws(
+            () => selectWithPreferences(preferencesDirectory, {
+                availableModelIds: ['auto'],
+                confirmedSuitableModelIds: ['auto'],
+                parentFallback: {
+                    isAllowed: true,
+                    hasMaterialCapabilityLoss: false,
+                },
+            }),
+            /confirmed suitable model ids must contain native model ids/,
+        );
+        const policy = JSON.parse(readFileSync(defaultSubagentModelPolicyPath(), 'utf8'));
+        policy.inheritanceAliases = ['custom-parent'];
+        const policyPath = join(preferencesDirectory, 'subagent-model-policy.json');
+        writeFileSync(policyPath, JSON.stringify(policy));
+        assert.throws(
+            () => selectWithPreferences(preferencesDirectory, {
+                availableModelIds: ['custom-parent'],
+                confirmedSuitableModelIds: [],
+                parentFallback: {
+                    isAllowed: true,
+                    hasMaterialCapabilityLoss: false,
+                },
+                policyPath,
+            }),
+            /available model ids must contain native model ids/,
+        );
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
 test('material capability loss requires a user choice before inheritance', () => {
     const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-parent-loss-'));
     try {
@@ -354,7 +447,7 @@ test('an optional-diversity review panel reports repeated models', () => {
     const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-review-panel-'));
     try {
         writeHostPreferences(preferencesDirectory, 'codex', {
-            'how critics': ['gpt-5.6-sol'],
+            'how critics': ['gpt-5.6-luna'],
         });
         const selection = selectWithPreferences(preferencesDirectory, {
             role: 'how critics',
@@ -363,16 +456,272 @@ test('an optional-diversity review panel reports repeated models', () => {
                 agentCount: 3,
                 requiresDistinctModels: false,
             },
-            availableModelIds: ['gpt-5.6-sol'],
+            availableModelIds: ['gpt-5.6-luna'],
         });
         assert.equal(selection.canDelegate, true);
         assert.deepEqual(selection.panel.selectedModelIds, [
-            'gpt-5.6-sol',
-            'gpt-5.6-sol',
-            'gpt-5.6-sol',
+            'gpt-5.6-luna',
+            'gpt-5.6-luna',
+            'gpt-5.6-luna',
         ]);
         assert.equal(selection.panel.isCrossModelDiverse, false);
     } finally {
         rmSync(preferencesDirectory, { recursive: true, force: true });
     }
-});
+});
+
+test('a model-only preference still goes through policy validation', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-model-only-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['unknown-model'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            availableModelIds: ['unknown-model'],
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.match(selection.failure, /model-routing-failed: model is unknown/);
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a model-only Terra preference uses the host effort before routing', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-terra-default-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['Terra'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            requestedEffort: 'medium',
+            availableModelIds: ['gpt-5.6-terra', 'gpt-5.6-luna'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-5.6-luna',
+            reasoning_effort: 'xhigh',
+        });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a profile default effort supplies a missing model-only effort', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-profile-default-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['Terra'],
+        }, 'medium');
+        const selection = selectWithPreferences(preferencesDirectory, {
+            requestedEffort: undefined,
+            availableModelIds: ['gpt-5.6-terra', 'gpt-5.6-luna'],
+        });
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-5.6-luna',
+            reasoning_effort: 'xhigh',
+        });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a model-only worker Astra preference uses the host effort before routing', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-astra-default-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['Astra'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            requestedEffort: 'high',
+            availableModelIds: ['gpt-6-astra'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-6-astra',
+            reasoning_effort: 'low',
+        });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a model-only preference holds when the host supplies no usable effort', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-missing-effort-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['Terra'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            requestedEffort: undefined,
+            availableModelIds: ['gpt-5.6-terra'],
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.match(selection.failure, /effort is required for this model/);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('non-Codex inheritance keeps its ordered parent fallback', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-parent-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'claude', {
+            'feature, refactoring': ['auto', 'opus'],
+        });
+        const selection = selectPstackDelegation({
+            host: 'claude',
+            inventoryHost: 'claude',
+            role: 'feature, refactoring',
+            delegationIndex: 0,
+            availableModelIds: ['opus'],
+            confirmedSuitableModelIds: [],
+            parentFallback: {
+                isAllowed: true,
+                hasMaterialCapabilityLoss: false,
+            },
+            preferencesDirectory,
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.equal(selection.omitNativeModelArgument, true);
+        assert.equal(selection.selectionSource, 'parent-inheritance');
+        assert.deepEqual(selection.panel.selectedModelIds, [null]);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('selector routes preference pairs before panel dedupe', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': [
+                { model: 'gpt-5.6-terra', effort: 'medium' },
+                { model: 'gpt-5.6-luna', effort: 'medium' },
+            ],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            panel: { agentCount: 2, requiresDistinctModels: false },
+            availableModelIds: ['gpt-5.6-terra', 'gpt-5.6-luna'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.deepEqual(selection.panel.selectedModelIds, [
+            'gpt-5.6-luna',
+            'gpt-5.6-luna',
+        ]);
+        assert.deepEqual(selection.panel.selectedModelPairs, [
+            { model: 'gpt-5.6-luna', effort: 'xhigh' },
+            { model: 'gpt-5.6-luna', effort: 'xhigh' },
+        ]);
+        assert.equal(selection.panel.isCrossModelDiverse, false);
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-5.6-luna',
+            reasoning_effort: 'xhigh',
+        });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('panel diversity uses selected models after routing', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-panel-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'arena runners': [
+                { model: 'gpt-5.6-terra', effort: 'medium' },
+                { model: 'gpt-5.6-sol', effort: 'medium' },
+                { model: 'gpt-6-astra', effort: 'medium' },
+            ],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'arena runners',
+            availableModelIds: [
+                'gpt-5.6-terra',
+                'gpt-5.6-sol',
+                'gpt-6-astra',
+                'gpt-5.6-luna',
+            ],
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.equal(selection.failure, 'distinct-models-unavailable');
+        assert.deepEqual(selection.panel.selectedModelIds, [
+            'gpt-5.6-luna',
+            'gpt-6-astra',
+        ]);
+        assert.equal(selection.panel.isCrossModelDiverse, false);
+        assert.deepEqual(selection.routingDiagnostics, []);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('selector keeps other Sol remaps as contenders', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-sol-remap-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': [{ model: 'gpt-5.6-sol', effort: 'high' }],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            availableModelIds: ['gpt-5.6-sol', 'gpt-6-astra'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.deepEqual(selection.panel.selectedModelIds, ['gpt-6-astra']);
+        assert.deepEqual(selection.panel.selectedModelPairs, [
+            { model: 'gpt-6-astra', effort: 'low' },
+        ]);
+        assert.deepEqual(selection.routingDiagnostics, []);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('unavailable routed models hold selection', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-unavailable-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': [{ model: 'gpt-5.6-terra', effort: 'medium' }],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            availableModelIds: ['gpt-5.6-terra'],
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.equal(selection.requiresUserChoice, true);
+        assert.match(selection.failure, /model-routing-failed: replacement model is unavailable/);
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('malformed routing policy holds selection with a diagnostic', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-policy-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': [{ model: 'gpt-5.6-terra', effort: 'medium' }],
+        });
+        const policyPath = join(preferencesDirectory, 'subagent-model-policy.json');
+        writeFileSync(policyPath, '{"schemaVersion":1}\n');
+        const selection = selectWithPreferences(preferencesDirectory, { policyPath });
+        assert.equal(selection.canDelegate, false);
+        assert.match(selection.failure, /model-routing-failed: models must be an object/);
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('an explicit missing policy path holds selection', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-missing-policy-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': [{ model: 'Terra', effort: 'medium' }],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            policyPath: join(preferencesDirectory, 'missing-policy.json'),
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.match(selection.failure, /policy file is missing/);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});