claude-dev-env 7.7.0 → 7.7.1

package/.agents/skills/e-code-review/reference/fix.md

@@ -21,8 +21,10 @@ every rule below.
 Before returning, the resumed agent runs the code-rules gate with the same bare
 call every other surface in this skill uses:
 
-1. Run `~/.claude/_shared/pr-loop/scripts/code_rules_gate.py --repo-root <repo
-   root>` with no file paths and no `--only-under` prefix.
+1. Run `python ~/.claude/_shared/pr-loop/scripts/code_rules_gate.py --repo-root
+   <repo root>` with no file paths and no `--only-under` prefix. The `python`
+   prefix is required. On Windows a bare `.py` path opens the file in Cursor,
+   which then crashes on the gate flags.
 2. If the gate reports violations **on lines this fix already owns** (the files
    and added lines the fix changed), fix them and re-run the exact same command.
 3. A violation on a path or added line outside this fix's own work is reported

package/.agents/skills/e-code-review/reference/loop.md

@@ -48,8 +48,10 @@ no advisor call reopens that.
 ## Required checks
 
 "Run required checks" means: run
-`~/.claude/_shared/pr-loop/scripts/code_rules_gate.py --repo-root <repo root>`
-with no file paths and no `--only-under` prefix. On a violation on lines this
+`python ~/.claude/_shared/pr-loop/scripts/code_rules_gate.py --repo-root <repo root>`
+with no file paths and no `--only-under` prefix. The `python` prefix is
+required. On Windows a bare `.py` path opens the file in Cursor, which then
+crashes on the gate flags. On a violation on lines this
 round already owns, fix it and re-run the exact same command until clean. A
 violation outside the review target is reported or skipped, not force-fixed into
 unrelated files, and the skip is logged with path and reason.

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

@@ -111,6 +111,38 @@ test('Codex preferences skip an excluded pair in a panel', () => {
     }
 });
 
+test('selector exclusions remove Sol Medium before its Luna remap enters a panel', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-sol-exclusion-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'how critics': [
+                { model: ' Sol ', effort: 'Medium' },
+                { model: 'gpt-5.6-sol', effort: 'medium' },
+                { model: 'gpt-5.6-luna', effort: 'high' },
+                { model: 'gpt-6-astra', effort: 'medium' },
+            ],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'how critics',
+            panel: { agentCount: 2, requiresDistinctModels: true },
+            availableModelIds: ['gpt-5.6-sol', 'gpt-5.6-luna', 'gpt-6-astra'],
+            confirmedSuitableModelIds: ['gpt-5.6-sol'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.deepEqual(selection.panel.selectedModelPairs, [
+            { model: 'gpt-5.6-luna', effort: 'high' },
+            { model: 'gpt-6-astra', effort: 'medium' },
+        ]);
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'gpt-5.6-luna',
+            reasoning_effort: 'high',
+        });
+        assert.deepEqual(selection.routingDiagnostics, []);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
 test('a foreign host reads only its own saved preferences', () => {
     const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-host-'));
     try {
@@ -563,6 +595,23 @@ test('a model-only preference holds when the host supplies no usable effort', ()
     }
 });
 
+test('a model-only Sol preference holds when no Sol effort remains approved', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-routing-sol-missing-effort-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['Sol'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            requestedEffort: undefined,
+            availableModelIds: ['gpt-5.6-sol', 'gpt-5.6-luna'],
+        });
+        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 {

package/bin/subagent-model-policy.test.mjs

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { cpSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -35,6 +35,7 @@ const replacements = [
     [['Luna', 'low'], ['gpt-5.6-luna', 'high']],
     [['Luna', 'medium'], ['gpt-5.6-luna', 'high']],
     [['Sol', 'low'], ['gpt-5.6-luna', 'xhigh']],
+    [['Sol', 'medium'], ['gpt-5.6-luna', 'max']],
     [['Terra', 'low'], ['gpt-5.6-luna', 'xhigh']],
     [['Terra', 'medium'], ['gpt-5.6-luna', 'xhigh']],
     [['Terra', 'high'], ['gpt-5.6-luna', 'xhigh']],
@@ -59,7 +60,6 @@ test('every approved pair returns its literal native pair', () => {
         [['Luna', 'high'], ['gpt-5.6-luna', 'high']],
         [['Luna', 'xhigh'], ['gpt-5.6-luna', 'xhigh']],
         [['Luna', 'max'], ['gpt-5.6-luna', 'max']],
-        [['Sol', 'medium'], ['gpt-5.6-sol', 'medium']],
         [['Astra', 'low'], ['gpt-6-astra', 'low']],
         [['Astra', 'medium'], ['gpt-6-astra', 'medium']],
     ];
@@ -67,6 +67,9 @@ test('every approved pair returns its literal native pair', () => {
         const result = route({ model, reasoning_effort: effort });
         assert.ok(['pass', 'remapped'].includes(result.status));
         assert.deepEqual(result.selected, { model: expectedModel, effort: expectedEffort });
+        const nativeRoute = route({ model: expectedModel, reasoning_effort: expectedEffort });
+        assert.equal(nativeRoute.status, 'pass');
+        assert.deepEqual(nativeRoute.selected, { model: expectedModel, effort: expectedEffort });
     }
     const advisor = advisorRoute({
         model: 'Astra',
@@ -77,12 +80,12 @@ test('every approved pair returns its literal native pair', () => {
     assert.deepEqual(advisor.selected, { model: 'gpt-6-astra', effort: 'high' });
 });
 
-test('selector exclusions leave direct Sol Medium routing valid', () => {
+test('selector exclusions keep Sol Medium out while direct routing remaps', () => {
     const policy = loadSubagentModelPolicy();
     assert.equal(policy.selectorExclusions.has('sol/medium'), true);
     const result = route({ model: 'Sol', reasoning_effort: 'medium' });
-    assert.ok(['pass', 'remapped'].includes(result.status));
-    assert.deepEqual(result.selected, { model: 'gpt-5.6-sol', effort: 'medium' });
+    assert.equal(result.status, 'remapped');
+    assert.deepEqual(result.selected, { model: 'gpt-5.6-luna', effort: 'max' });
 
     const rawPolicy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
     rawPolicy.selectorExclusions = [{ model: 'missing', effort: 'medium' }];
@@ -174,6 +177,25 @@ test('the advisor bridge blocks malformed input', () => {
     );
 });
 
+test('the advisor bridge routes Sol Medium to Luna Max', () => {
+    const bridgePath = join(PACKAGE_ROOT, 'scripts', 'resolve_advisor_model_route.mjs');
+    const bridgeExecution = spawnSync(
+        process.execPath,
+        [bridgePath],
+        {
+            encoding: 'utf8',
+            input: JSON.stringify({ model: 'Sol', reasoning_effort: 'medium' }),
+        },
+    );
+    assert.equal(bridgeExecution.status, 0);
+    assert.equal(bridgeExecution.stderr, '');
+    const advisorDecision = JSON.parse(bridgeExecution.stdout);
+    assert.equal(advisorDecision.status, 'remapped');
+    assert.equal(advisorDecision.role, 'advisor');
+    assert.equal(advisorDecision.diagnostic, null);
+    assert.deepEqual(advisorDecision.selected, { model: 'gpt-5.6-luna', effort: 'max' });
+});
+
 test('missing worker settings preserve parent inheritance', () => {
     const input = { message: 'keep', agent_type: 'worker' };
     const result = routeSubagentToolInput(input);
@@ -181,6 +203,15 @@ test('missing worker settings preserve parent inheritance', () => {
     assert.strictEqual(result.updatedInput, input);
 });
 
+test('Sol without an effort stays blocked after its only approved pair is removed', () => {
+    const result = route(
+        { model: 'Sol' },
+        { allowMissingEffort: true },
+    );
+    assert.equal(result.status, 'blocked');
+    assert.equal(result.diagnostic, 'effort is required for this model');
+});
+
 test('unknown input holds with a short diagnostic', () => {
     assert.match(route({ model: 'Unknown', reasoning_effort: 'medium' }).diagnostic, /model is unknown/);
     assert.match(route({ model: 'Terra', reasoning_effort: 'future' }).diagnostic, /effort is unknown/);
@@ -201,16 +232,16 @@ test('native values with case or whitespace differences are canonicalized', () =
     });
     assert.equal(result.status, 'remapped');
     assert.deepEqual(result.updatedInput, {
-        model: 'gpt-5.6-sol',
-        reasoning_effort: 'medium',
+        model: 'gpt-5.6-luna',
+        reasoning_effort: 'max',
         message: 'keep',
     });
 });
 
 test('unavailable replacements hold the spawn', () => {
     const result = route(
-        { model: 'Terra', reasoning_effort: 'medium' },
-        { availableModelIds: ['gpt-5.6-terra'] },
+        { model: 'Sol', reasoning_effort: 'medium' },
+        { availableModelIds: ['gpt-5.6-sol'] },
     );
     assert.equal(result.status, 'blocked');
     assert.match(result.diagnostic, /replacement model is unavailable/);
@@ -246,7 +277,7 @@ test('the tool route copies every non-routing field', () => {
 
 test('a second route pass is idempotent', () => {
     const first = routeSubagentToolInput(
-        { model: 'Terra', reasoning_effort: 'medium', message: 'keep' },
+        { model: 'Sol', reasoning_effort: 'medium', message: 'keep' },
         {},
     );
     const second = routeSubagentToolInput(first.updatedInput);
@@ -261,17 +292,22 @@ test('a temporary policy copy changes the next route without source edits', () =
         const temporaryPolicy = join(temporaryRoot, 'policy.json');
         const sourceText = readFileSync(POLICY_SOURCE, 'utf8');
         const policy = JSON.parse(sourceText);
+        writeFileSync(temporaryPolicy, sourceText);
+        assert.deepEqual(route(
+            { model: 'Sol', reasoning_effort: 'medium' },
+            { policyPath: temporaryPolicy },
+        ).selected, { model: 'gpt-5.6-luna', effort: 'max' });
         policy.replacements = policy.replacements.map(replacement => (
-            replacement.requested.model === 'terra' && replacement.requested.effort === 'medium'
-                ? { ...replacement, selected: { model: 'luna', effort: 'max' } }
+            replacement.requested.model === 'sol' && replacement.requested.effort === 'medium'
+                ? { ...replacement, selected: { model: 'luna', effort: 'xhigh' } }
                 : replacement
         ));
         writeFileSync(temporaryPolicy, JSON.stringify(policy));
-        const result = route(
-            { model: 'Terra', reasoning_effort: 'medium' },
+        const updatedRoute = route(
+            { model: 'Sol', reasoning_effort: 'medium' },
             { policyPath: temporaryPolicy },
         );
-        assert.deepEqual(result.selected, { model: 'gpt-5.6-luna', effort: 'max' });
+        assert.deepEqual(updatedRoute.selected, { model: 'gpt-5.6-luna', effort: 'xhigh' });
         assert.equal(readFileSync(POLICY_SOURCE, 'utf8'), sourceText);
     } finally {
         rmSync(temporaryRoot, { recursive: true, force: true });
@@ -347,10 +383,11 @@ test('model names cannot collide after normalization', () => {
 
 test('combined role routes must end at an approved terminal pair', () => {
     const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
-    policy.replacements.push({
-        requested: { model: 'sol', effort: 'medium' },
-        selected: { model: 'astra', effort: 'low' },
-    });
+    const solMediumReplacement = policy.replacements.find(replacement => (
+        replacement.requested.model === 'sol'
+        && replacement.requested.effort === 'medium'
+    ));
+    solMediumReplacement.selected = { model: 'astra', effort: 'low' };
     policy.roleReplacements.push({
         role: 'worker',
         requested: { model: 'astra', effort: 'low' },

package/docs/subagent-model-routing.md

@@ -32,8 +32,11 @@ example, change the `terra` and `medium` entry in `replacements` to:
 
 The next routing call reads the file again. The resolver source stays unchanged.
 
-To keep a pair out of selector panels, add it to `selectorExclusions`. This
-does not block the shared resolver or the spawn hook. For example:
+Selector exclusions keep a pair out of panels. They do not change direct route
+decisions. The shipped policy keeps Sol Medium out of panels and routes direct
+requests for Sol Medium to Luna Max through `replacements`. Sol Medium is absent
+from `approvedPairs`. The selector drops the requested pair before routing it,
+so its Luna replacement does not enter the panel through that preference.
 
 ```json
 "selectorExclusions": [
@@ -41,9 +44,25 @@ does not block the shared resolver or the spawn hook. For example:
 ]
 ```
 
+The matching replacement is:
+
+```json
+{
+  "requested": {"model": "sol", "effort": "medium"},
+  "selected": {"model": "luna", "effort": "max"}
+}
+```
+
 Unknown values, invalid policy data, and unavailable replacement models stop the
 spawn with a short diagnostic. Parent inheritance stays unchanged.
 
+The direct spawn hook and advisor bridge use the same shared resolver. A Sol
+Medium remap changes only the model and effort fields in the hook's tool input.
+The hook returns an allow decision with the updated input and emits no remap
+notice. Luna High, Xhigh, and Max and Astra Low and Medium keep their routes.
+Trusted advisors also keep Astra High. A worker request for Sol without an
+effort stops because Sol has no approved pair to supply a default effort.
+
 The hook blocks advisor role claims because the current Codex hook input has no
 host-provided role binding. The Python advisor bridge passes trusted session
 metadata to the shared resolver. The native advisor hook path stays pending

package/hooks/routing/subagent_model_routing.test.mjs

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { test } from 'node:test';
 import { fileURLToPath } from 'node:url';
 
@@ -11,22 +11,22 @@ function buildHookPayload(toolInput, metadata = {}) {
     return { tool_name: targetToolName, tool_input: toolInput, ...metadata };
 }
 
-test('remaps Terra Medium to Luna Xhigh', () => {
+test('remaps Sol Medium to Luna Max', () => {
     const hookResponse = buildSubagentModelRoutingResponse(buildHookPayload({
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'Medium',
     }));
 
     assert.equal(hookResponse.hookSpecificOutput.updatedInput.model, 'gpt-5.6-luna');
     assert.equal(
         hookResponse.hookSpecificOutput.updatedInput.reasoning_effort,
-        'xhigh',
+        'max',
     );
 });
 
 test('emits only the allow response shape after a remap', () => {
     const hookResponse = buildSubagentModelRoutingResponse(buildHookPayload({
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
     }));
 
@@ -41,7 +41,7 @@ test('emits only the allow response shape after a remap', () => {
         permissionDecision: 'allow',
         updatedInput: {
             model: 'gpt-5.6-luna',
-            reasoning_effort: 'xhigh',
+            reasoning_effort: 'max',
         },
     });
 });
@@ -52,7 +52,7 @@ test('preserves every non-routing tool field', () => {
         message: 'do the work',
         child_permissions: { shell: 'ask' },
         output_contract: ['summary'],
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
     };
 
@@ -64,14 +64,14 @@ test('preserves every non-routing tool field', () => {
         child_permissions: { shell: 'ask' },
         output_contract: ['summary'],
         model: 'gpt-5.6-luna',
-        reasoning_effort: 'xhigh',
+        reasoning_effort: 'max',
     });
     assert.deepEqual(toolInput, {
         assignment: 'preserve',
         message: 'do the work',
         child_permissions: { shell: 'ask' },
         output_contract: ['summary'],
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
     });
 });
@@ -94,8 +94,8 @@ test('blocks malformed policy, unknown input, unavailable replacement, and untru
         buildHookPayload({ model: 'Unknown', reasoning_effort: 'medium' }),
     );
     const unavailableReplacementResponse = buildSubagentModelRoutingResponse(
-        buildHookPayload({ model: 'Terra', reasoning_effort: 'medium' }),
-        { availableModelIds: ['gpt-5.6-terra'] },
+        buildHookPayload({ model: 'Sol', reasoning_effort: 'medium' }),
+        { availableModelIds: ['gpt-5.6-sol'] },
     );
     const untrustedAdvisorResponse = buildSubagentModelRoutingResponse(
         buildHookPayload({
@@ -122,25 +122,62 @@ test('blocks malformed policy, unknown input, unavailable replacement, and untru
     }
 });
 
-test('allows a registered session advisor with trusted session metadata', () => {
-    const hookResponse = buildSubagentModelRoutingResponse(
-        buildHookPayload({
+for (const [eachModel, eachEffort, eachSelectedModel, eachSelectedEffort] of [
+    ['Sol', 'medium', 'gpt-5.6-luna', 'max'],
+    ['Astra', 'high', 'gpt-6-astra', 'high'],
+]) {
+    test(`allows a trusted session advisor requesting ${eachModel} ${eachEffort}`, () => {
+        const hookResponse = buildSubagentModelRoutingResponse(
+            buildHookPayload({
+                agent_type: 'session-advisor',
+                model: eachModel,
+                reasoning_effort: eachEffort,
+            }),
+            {
+                trustedSessionMetadata: {
+                    authorized: true,
+                    registeredAgentType: 'session-advisor',
+                },
+            },
+        );
+
+        assert.deepEqual(hookResponse.hookSpecificOutput.updatedInput, {
             agent_type: 'session-advisor',
-            model: 'Astra',
-            reasoning_effort: 'high',
-        }),
+            model: eachSelectedModel,
+            reasoning_effort: eachSelectedEffort,
+        });
+    });
+}
+
+test('the standalone hook silently remaps native Sol Medium and preserves other fields', () => {
+    const hookExecution = spawnSync(
+        process.execPath,
+        [fileURLToPath(new URL('./subagent_model_routing.mjs', import.meta.url))],
         {
-            trustedSessionMetadata: {
-                authorized: true,
-                registeredAgentType: 'session-advisor',
-            },
+            encoding: 'utf8',
+            input: JSON.stringify(buildHookPayload({
+                model: 'gpt-5.6-sol',
+                effort: 'medium',
+                message: 'keep',
+                child_permissions: { shell: 'ask' },
+                output_contract: ['summary'],
+            })),
         },
     );
-
-    assert.deepEqual(hookResponse.hookSpecificOutput.updatedInput, {
-        agent_type: 'session-advisor',
-        model: 'gpt-6-astra',
-        reasoning_effort: 'high',
+    assert.equal(hookExecution.status, 0);
+    assert.equal(hookExecution.stderr, '');
+    assert.deepEqual(JSON.parse(hookExecution.stdout), {
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'allow',
+            updatedInput: {
+                model: 'gpt-5.6-luna',
+                effort: 'max',
+                message: 'keep',
+                child_permissions: { shell: 'ask' },
+                output_contract: ['summary'],
+            },
+        },
     });
 });
 
@@ -201,7 +238,7 @@ test('the standalone hook command blocks an advisor without host metadata', () =
 
 test('keeps a second routing pass unchanged', () => {
     const firstResponse = buildSubagentModelRoutingResponse(buildHookPayload({
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
         message: 'keep',
     }));
@@ -212,7 +249,7 @@ test('keeps a second routing pass unchanged', () => {
     assert.deepEqual(secondResponse, {});
     assert.deepEqual(firstResponse.hookSpecificOutput.updatedInput, {
         model: 'gpt-5.6-luna',
-        reasoning_effort: 'xhigh',
+        reasoning_effort: 'max',
         message: 'keep',
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "7.7.0",
+    "version": "7.7.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/subagent-model-policy.json

@@ -53,7 +53,6 @@
     {"model": "luna", "effort": "high"},
     {"model": "luna", "effort": "xhigh"},
     {"model": "luna", "effort": "max"},
-    {"model": "sol", "effort": "medium"},
     {"model": "astra", "effort": "low"},
     {"model": "astra", "effort": "medium"},
     {"model": "astra", "effort": "high", "roles": ["advisor"]}
@@ -66,6 +65,7 @@
     {"requested": {"model": "luna", "effort": "low"}, "selected": {"model": "luna", "effort": "high"}},
     {"requested": {"model": "luna", "effort": "medium"}, "selected": {"model": "luna", "effort": "high"}},
     {"requested": {"model": "sol", "effort": "low"}, "selected": {"model": "luna", "effort": "xhigh"}},
+    {"requested": {"model": "sol", "effort": "medium"}, "selected": {"model": "luna", "effort": "max"}},
     {"requested": {"model": "terra", "effort": "low"}, "selected": {"model": "luna", "effort": "xhigh"}},
     {"requested": {"model": "terra", "effort": "medium"}, "selected": {"model": "luna", "effort": "xhigh"}},
     {"requested": {"model": "terra", "effort": "high"}, "selected": {"model": "luna", "effort": "xhigh"}},