claude-dev-env 7.6.1 → 7.7.1

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

@@ -0,0 +1,436 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+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';
+import { fileURLToPath } from 'node:url';
+import {
+    defaultSubagentModelPolicyPath,
+    loadSubagentModelPolicy,
+    resolveSubagentModelRoute,
+    routeSubagentToolInput,
+    SubagentModelPolicyError,
+    validateSubagentModelPolicy,
+} from '../scripts/subagent_model_policy.mjs';
+
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const POLICY_SOURCE = defaultSubagentModelPolicyPath();
+
+function route(request, options = {}) {
+    return resolveSubagentModelRoute(request, options);
+}
+
+function advisorRoute(request, options = {}) {
+    return route(request, {
+        trustedSessionMetadata: {
+            authorized: true,
+            registeredAgentType: 'session-advisor',
+        },
+        ...options,
+    });
+}
+
+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']],
+    [['Terra', 'xhigh'], ['gpt-5.6-luna', 'max']],
+    [['Sol', 'high'], ['gpt-6-astra', 'low']],
+    [['Sol', 'xhigh'], ['gpt-6-astra', 'low']],
+    [['Sol', 'max'], ['gpt-6-astra', 'low']],
+    [['Terra', 'max'], ['gpt-6-astra', 'low']],
+];
+
+test('the shipped policy parses and names native model ids', () => {
+    const policy = loadSubagentModelPolicy();
+    assert.equal(policy.modelByName.astra.id, 'gpt-6-astra');
+    assert.equal(policy.modelByName.sol.id, 'gpt-5.6-sol');
+    assert.equal(policy.modelByName.terra.id, 'gpt-5.6-terra');
+    assert.equal(policy.modelByName.luna.id, 'gpt-5.6-luna');
+    assert.deepEqual(policy.advisorDefault, { model: 'astra', effort: 'medium' });
+});
+
+test('every approved pair returns its literal native pair', () => {
+    const expected = [
+        [['Luna', 'high'], ['gpt-5.6-luna', 'high']],
+        [['Luna', 'xhigh'], ['gpt-5.6-luna', 'xhigh']],
+        [['Luna', 'max'], ['gpt-5.6-luna', 'max']],
+        [['Astra', 'low'], ['gpt-6-astra', 'low']],
+        [['Astra', 'medium'], ['gpt-6-astra', 'medium']],
+    ];
+    for (const [[model, effort], [expectedModel, expectedEffort]] of expected) {
+        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',
+        reasoning_effort: 'high',
+        agent_type: 'session-advisor',
+    });
+    assert.equal(advisor.status, 'remapped');
+    assert.deepEqual(advisor.selected, { model: 'gpt-6-astra', effort: 'high' });
+});
+
+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.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' }];
+    assert.throws(
+        () => validateSubagentModelPolicy(rawPolicy),
+        /selectorExclusions entry has unknown model/,
+    );
+});
+
+test('every automatic replacement returns its literal destination', () => {
+    for (const [[model, effort], [expectedModel, expectedEffort]] of replacements) {
+        const result = route({ model, reasoning_effort: effort });
+        assert.equal(result.status, 'remapped');
+        assert.deepEqual(result.selected, { model: expectedModel, effort: expectedEffort });
+    }
+});
+
+test('advisor and worker Astra restrictions use role-specific replacements', () => {
+    assert.deepEqual(
+        advisorRoute({ model: 'Astra', reasoning_effort: 'xhigh', agent_type: 'session-advisor' }).selected,
+        { model: 'gpt-6-astra', effort: 'medium' },
+    );
+    assert.deepEqual(
+        route({ model: 'Astra', reasoning_effort: 'max', agent_type: 'worker' }).selected,
+        { model: 'gpt-6-astra', effort: 'low' },
+    );
+    assert.deepEqual(
+        advisorRoute({ model: 'Astra', reasoning_effort: 'high', agent_type: 'session-advisor' }).selected,
+        { model: 'gpt-6-astra', effort: 'high' },
+    );
+});
+
+test('registered advisor roles satisfy advisory authorization', () => {
+    const result = advisorRoute({
+        model: 'Astra',
+        reasoning_effort: 'high',
+        agent_type: 'session-advisor',
+    });
+
+    assert.deepEqual(result.selected, { model: 'gpt-6-astra', effort: 'high' });
+});
+
+test('a policy from the first stack revision remains routable', () => {
+    const legacyPolicy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    delete legacyPolicy.roles.trustedAdvisor;
+    const result = advisorRoute(
+        {
+            model: 'Astra',
+            reasoning_effort: 'high',
+            agent_type: 'session-advisor',
+        },
+        { policy: legacyPolicy },
+    );
+    assert.deepEqual(result.selected, { model: 'gpt-6-astra', effort: 'high' });
+});
+
+test('an advisor role claim cannot grant advisory authorization', () => {
+    const result = route({
+        model: 'Astra',
+        reasoning_effort: 'high',
+        agent_type: 'session-advisor',
+    });
+    assert.equal(result.status, 'blocked');
+    assert.equal(result.diagnostic, 'advisor role is not trusted');
+});
+
+test('Astra Light resolves to Astra Low', () => {
+    const result = route({ model: 'Astra', reasoning_effort: 'Light' });
+    assert.deepEqual(result.selected, { model: 'gpt-6-astra', effort: 'low' });
+});
+
+test('missing advisor settings use the policy default', () => {
+    const result = advisorRoute({ agent_type: 'session-advisor' });
+    assert.deepEqual(result.selected, { model: 'gpt-6-astra', effort: 'medium' });
+});
+
+test('the advisor bridge blocks malformed input', () => {
+    const bridgePath = join(PACKAGE_ROOT, 'scripts', 'resolve_advisor_model_route.mjs');
+    assert.throws(
+        () => execFileSync(process.execPath, [bridgePath], { encoding: 'utf8', input: '{' }),
+        error => {
+            assert.equal(error.status, 1);
+            assert.deepEqual(JSON.parse(error.stdout), {
+                status: 'blocked',
+                diagnostic: 'advisor route input is not valid JSON',
+            });
+            return true;
+        },
+    );
+});
+
+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);
+    assert.equal(result.status, 'inherited');
+    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/);
+    assert.match(route({ model: 'Sol', reasoning_effort: 'medium', agent_type: 'unregistered' }).diagnostic, /role is unknown/);
+});
+
+test('dual effort fields hold instead of leaving one stale', () => {
+    const result = route({ model: 'Luna', reasoning_effort: 'low', effort: 'low' });
+    assert.equal(result.status, 'blocked');
+    assert.match(result.diagnostic, /effort fields are ambiguous/);
+});
+
+test('native values with case or whitespace differences are canonicalized', () => {
+    const result = routeSubagentToolInput({
+        model: ' gpt-5.6-sol ',
+        reasoning_effort: 'Medium',
+        message: 'keep',
+    });
+    assert.equal(result.status, 'remapped');
+    assert.deepEqual(result.updatedInput, {
+        model: 'gpt-5.6-luna',
+        reasoning_effort: 'max',
+        message: 'keep',
+    });
+});
+
+test('unavailable replacements hold the spawn', () => {
+    const result = route(
+        { model: 'Sol', reasoning_effort: 'medium' },
+        { availableModelIds: ['gpt-5.6-sol'] },
+    );
+    assert.equal(result.status, 'blocked');
+    assert.match(result.diagnostic, /replacement model is unavailable/);
+});
+
+test('the tool route copies every non-routing field', () => {
+    const input = {
+        assignment: 'preserve',
+        message: 'do the work',
+        child_permissions: { shell: 'ask' },
+        output_contract: ['summary'],
+        model: 'Terra',
+        reasoning_effort: 'Medium',
+    };
+    const result = routeSubagentToolInput(input);
+    assert.deepEqual(result.updatedInput, {
+        assignment: 'preserve',
+        message: 'do the work',
+        child_permissions: { shell: 'ask' },
+        output_contract: ['summary'],
+        model: 'gpt-5.6-luna',
+        reasoning_effort: 'xhigh',
+    });
+    assert.deepEqual(input, {
+        assignment: 'preserve',
+        message: 'do the work',
+        child_permissions: { shell: 'ask' },
+        output_contract: ['summary'],
+        model: 'Terra',
+        reasoning_effort: 'Medium',
+    });
+});
+
+test('a second route pass is idempotent', () => {
+    const first = routeSubagentToolInput(
+        { model: 'Sol', reasoning_effort: 'medium', message: 'keep' },
+        {},
+    );
+    const second = routeSubagentToolInput(first.updatedInput);
+    assert.equal(first.status, 'remapped');
+    assert.equal(second.status, 'pass');
+    assert.deepEqual(second.updatedInput, first.updatedInput);
+});
+
+test('a temporary policy copy changes the next route without source edits', () => {
+    const temporaryRoot = mkdtempSync(join(tmpdir(), 'subagent-policy-'));
+    try {
+        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 === 'sol' && replacement.requested.effort === 'medium'
+                ? { ...replacement, selected: { model: 'luna', effort: 'xhigh' } }
+                : replacement
+        ));
+        writeFileSync(temporaryPolicy, JSON.stringify(policy));
+        const updatedRoute = route(
+            { model: 'Sol', reasoning_effort: 'medium' },
+            { policyPath: temporaryPolicy },
+        );
+        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 });
+    }
+});
+
+test('malformed policy data fails validation', () => {
+    assert.throws(
+        () => validateSubagentModelPolicy({ schemaVersion: 1 }),
+        error => error instanceof SubagentModelPolicyError && /models must be an object/.test(error.message),
+    );
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    assert.throws(
+        () => validateSubagentModelPolicy({
+            ...policy,
+            replacements: [
+                {
+                    requested: { model: 'terra', effort: 'medium' },
+                    selected: { model: 'terra', effort: 'medium' },
+                },
+            ],
+        }),
+        /replacement target is not approved/,
+    );
+    const blocked = resolveSubagentModelRoute(
+        { model: 'Terra', reasoning_effort: 'medium' },
+        { policy: { schemaVersion: 1 } },
+    );
+    assert.equal(blocked.status, 'blocked');
+    assert.match(blocked.diagnostic, /models must be an object/);
+});
+
+test('a copied policy cannot forge the validated-policy marker', () => {
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    const validatedPolicy = validateSubagentModelPolicy(policy);
+    const copiedPolicy = { ...validatedPolicy, models: {} };
+    const result = resolveSubagentModelRoute(
+        { model: 'Terra', reasoning_effort: 'medium' },
+        { policy: copiedPolicy },
+    );
+    assert.equal(result.status, 'blocked');
+    assert.match(result.diagnostic, /models must not be empty/);
+});
+
+test('normalized effort aliases resolve from the validated policy', () => {
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    policy.efforts.aliases = { Light: 'LOW' };
+    const validatedPolicy = validateSubagentModelPolicy(policy);
+    const result = resolveSubagentModelRoute(
+        { model: 'Astra', reasoning_effort: 'Light' },
+        { policy: validatedPolicy },
+    );
+    assert.deepEqual(result.selected, { model: 'gpt-6-astra', effort: 'low' });
+});
+
+test('inheritance aliases cannot shadow model aliases', () => {
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    policy.inheritanceAliases = ['astra'];
+    assert.throws(
+        () => validateSubagentModelPolicy(policy),
+        /inheritance alias conflicts with a model alias/,
+    );
+});
+
+test('model names cannot collide after normalization', () => {
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    policy.models.Astra = { id: 'gpt-6-astra-copy', aliases: [] };
+    assert.throws(
+        () => validateSubagentModelPolicy(policy),
+        /model name is ambiguous: astra/,
+    );
+});
+
+test('combined role routes must end at an approved terminal pair', () => {
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    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' },
+        selected: { model: 'luna', effort: 'high' },
+    });
+    assert.throws(
+        () => validateSubagentModelPolicy(policy),
+        /replacement destination is not terminal/,
+    );
+});
+
+test('replacement cycles fail policy validation', () => {
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    policy.replacements.push(
+        {
+            requested: { model: 'luna', effort: 'high' },
+            selected: { model: 'luna', effort: 'xhigh' },
+        },
+        {
+            requested: { model: 'luna', effort: 'xhigh' },
+            selected: { model: 'luna', effort: 'high' },
+        },
+    );
+    assert.throws(
+        () => validateSubagentModelPolicy(policy),
+        /replacement cycle includes/,
+    );
+});
+
+test('base replacement targets must be approved for every role', () => {
+    const policy = JSON.parse(readFileSync(POLICY_SOURCE, 'utf8'));
+    policy.replacements = policy.replacements.map(replacement => (
+        replacement.requested.model === 'terra' && replacement.requested.effort === 'medium'
+            ? { ...replacement, selected: { model: 'astra', effort: 'high' } }
+            : replacement
+    ));
+    assert.throws(
+        () => validateSubagentModelPolicy(policy),
+        /replacement target is not approved: astra\/high/,
+    );
+});
+
+test('policy aliases stay in the policy file', () => {
+    const source = readFileSync(join(PACKAGE_ROOT, 'scripts', 'subagent_model_policy.mjs'), 'utf8');
+    assert.doesNotMatch(source, /gpt-5\.6-(?:luna|sol|terra)|gpt-6-astra/);
+});

package/docs/codex-compatibility.md

@@ -1,6 +1,6 @@
 # Codex compatibility entry point
 
-`codex-compat` is an optional, explicit bridge from this package's Claude-oriented source tree to Codex-compatible records. The existing `claude-dev-env` installer is unchanged and does not invoke it.
+`codex-compat` is an optional, explicit bridge from this package's Claude-oriented source tree to Codex-compatible records. The package installer also registers the supported native subagent routing hook in the selected Codex home.
 
 ## Materialization
 
@@ -22,6 +22,20 @@ A missing or unreadable source root is an error, and the run changes nothing. An
 
 Run `codex-compat bridge --surface <name> --payload '<json-object>'`. The bridge exposes the Python translation logic directly. `TaskCreate` and `TaskUpdate` map to `update_plan`; spawn, message, wait, and stop map to multi-agent surfaces. `ScheduleWakeup` is explicitly unsupported and requires manual review.
 
+## Automatic model routing
+
+The package installer seeds `subagent-model-policy.json` in the agents-home
+`rules/` directory when the file is absent. It registers one `PreToolUse` group
+for `multi_agent_v1__spawn_agent` in `$CODEX_HOME/hooks.json`. Existing Codex
+hook groups stay in place. Claude-only hook groups do not enter the Codex file.
+
+Edit the installed policy file to change the next routing decision. The resolver
+loads that path for each invocation.
+
+The default `.claude` target uses `CODEX_HOME`. A named profile or another
+target uses `<managed-root>/.codex`, so launch that profile with the same
+`CODEX_HOME` value.
+
 ## Per-message context injection (manual wiring)
 
 Codex reads the same `hookSpecificOutput.additionalContext` shape as Claude,
@@ -46,9 +60,8 @@ Add this by hand to `$CODEX_HOME/hooks.json` (merge it into an existing file):
 }
 ```
 
-Limits:
-
-- The installer skips Codex `hooks.json` for now. Wire it by hand.
+The package installer does not register this optional context hook. Add it by
+hand when the host should receive that context.
 
 ## Luna fast-mode guard
 
@@ -71,4 +84,5 @@ The guard requires exact `fast` for Luna spawns through `Agent` and `Task`. Nati
 
 ## Roots and safety
 
-Both roots are caller-supplied. The tool never writes to `.agents` or `CODEX_HOME` automatically; pass those locations explicitly when desired. No personal paths or secrets are embedded in the package.
+Both materializer roots are caller-supplied. The tool writes only inside those
+roots. No personal paths or secrets are embedded in the package.

package/docs/subagent-model-routing.md

@@ -0,0 +1,69 @@
+# Automatic child model choices
+
+The package routes native subagent requests before the child starts. It keeps
+approved pairs, aliases, replacements, selector exclusions, and the advisor
+default in one file.
+
+The source policy is
+`packages/claude-dev-env/rules/subagent-model-policy.json`.
+
+After install, the editable file is
+`<agents-home>/rules/subagent-model-policy.json`.
+
+The installer creates this file only when it is absent. Later installs keep the
+file and its edits. The main profile uses the `.agents` directory beside
+`.claude`. A named profile uses its matching `<profile>.agents` directory.
+
+To change a route, edit the `selected` pair for one `requested` pair. For
+example, change the `terra` and `medium` entry in `replacements` to:
+
+```json
+{
+  "requested": {
+    "model": "terra",
+    "effort": "medium"
+  },
+  "selected": {
+    "model": "luna",
+    "effort": "max"
+  }
+}
+```
+
+The next routing call reads the file again. The resolver source stays unchanged.
+
+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": [
+  {"model": "sol", "effort": "medium"}
+]
+```
+
+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
+until the host supplies that binding.

package/hooks/hooks.json

@@ -2,6 +2,16 @@
   "description": "Code standards enforcement, safety guards, and development workflow hooks",
   "hooks": {
     "PreToolUse": [
+      {
+        "matcher": "multi_agent_v1__spawn_agent",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/routing/subagent_model_routing.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
       {
         "matcher": "Write|Edit|MultiEdit|apply_patch",
         "hooks": [

package/hooks/routing/subagent_model_routing.mjs

@@ -0,0 +1,81 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { routeSubagentToolInput } from '../../scripts/subagent_model_policy.mjs';
+
+const targetToolName = 'multi_agent_v1__spawn_agent';
+const hookEventName = 'PreToolUse';
+const defaultBlockingDiagnostic = 'subagent model routing blocked';
+
+export function buildSubagentModelRoutingResponse(hookPayload, routingOptions = {}) {
+    if (!isObject(hookPayload)) return buildBlockedResponse('hook input must be an object');
+    if (!isTargetSubagentTool(hookPayload)) return {};
+
+    const routeOptions = buildRouteOptions(hookPayload, routingOptions);
+    const routingDecision = routeToolInput(hookPayload.tool_input, routeOptions);
+    if (routingDecision.status === 'blocked') {
+        return buildBlockedResponse(routingDecision.diagnostic);
+    }
+    if (routingDecision.status !== 'remapped') return {};
+
+    return buildAllowResponse(routingDecision.updatedInput);
+}
+
+export function main(serializedInput = readFileSync(0, 'utf8')) {
+    let hookPayload;
+    try {
+        hookPayload = JSON.parse(serializedInput);
+    } catch {
+        hookPayload = null;
+    }
+
+    const hookResponse = hookPayload === null
+        ? buildBlockedResponse('hook input is not valid JSON')
+        : buildSubagentModelRoutingResponse(hookPayload);
+    process.stdout.write(JSON.stringify(hookResponse));
+}
+
+function buildRouteOptions(hookPayload, routingOptions) {
+    const routeOptions = { ...routingOptions };
+    const availableModelIds = routeOptions.availableModelIds
+        ?? hookPayload.availableModelIds
+        ?? hookPayload.available_model_ids;
+    if (availableModelIds !== undefined) routeOptions.availableModelIds = availableModelIds;
+    return routeOptions;
+}
+
+function routeToolInput(toolInput, routeOptions) {
+    return routeSubagentToolInput(toolInput, routeOptions);
+}
+
+function isTargetSubagentTool(hookPayload) {
+    return hookPayload.tool_name === targetToolName;
+}
+
+function buildAllowResponse(updatedInput) {
+    return {
+        hookSpecificOutput: {
+            hookEventName,
+            permissionDecision: 'allow',
+            updatedInput,
+        },
+    };
+}
+
+function buildBlockedResponse(diagnostic) {
+    return {
+        hookSpecificOutput: {
+            hookEventName,
+            permissionDecision: 'deny',
+            permissionDecisionReason: diagnostic || defaultBlockingDiagnostic,
+        },
+    };
+}
+
+function isObject(candidate) {
+    return candidate !== null && typeof candidate === 'object' && !Array.isArray(candidate);
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+    main();
+}