claude-dev-env 7.6.1 → 7.7.0

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 });
+    }
+});